Relativbewegung in Z+ in Pulsejob

    Hiho,


    nur vorneweg. Ich hab noch nie Motoman programmiert, hab keinen zur Hand und krieg auch keine Schulung, mus aber trotzdem ein Programm dafür schreiben. Hab ich soweit auch gemacht, aus den Infos, die ich im Netz, Handbüchern und im Forum gefunden hab. Wär aber super, wenn da nochmal jemand drüberschauen kann, der halt einfach Ahnung von Motoman hat. Im prinzip ist es recht simpel, der Roboter soll in World Z+ 100mm über einen Punkt fahren, dann diesen Punkt anfahren und dann wieder auf den Punkt 100mm darüber. Also eigentlich ne relativbewegung an z+, das ganze aber halt als Pulsejob.


    Mein Ansatz dazu (ausgehend von der Lösung zu http://www.roboterforum.de/rob…g_um_den_tcp-t4676.0.html) ist:


    /JOB
    //NAME test
    //POS
    ///NPOS 16,0,0,0,0,0
    ///TOOL 10
    ///POSTYPE PULSE
    ///PULSE
    C00003=0,0,0,0,0,0
    C00010=0,0,0,0,0,0
    P0000=0,0,0,0,0,0
    //INST
    ///DATE 2009/10/05 12:00
    ///ATTR SC,RW
    ///GROUP1 RB1
    NOP


    GETS C00003 P0000 'geteachte Position C03 in tempPos speichern
    CNVRT P0000 RF 'in Roboterkoordinaten umrechnen
    ADD P0000 (3) 100 'z+100


    MOVL P0000 VL=10.00
    MOVL C00003 VL=10.00
    MOVL P0000 VL=10.00


    END


    Kann mir jemand sagen ob das so geht oder obs da nen besseren Weg gibt?


    Dann würd mich noch interessieren was für eine Positionsvariable das C genau ist. Das find ich net im NX Programmierhandbuch.


    Mfg
    Thadäus

    • ANZEIGE

    allo,
    Wenn ich das richtig verstanden habe dann hast du
    den Punkt, den du anfahren willst, geteacht?


    Am einfachsten ist es, wenn du den Punkt in eine P-Variable im Basis-Frame und in PULSE speicherst.
    Beispielsweise in P010 und P011
    Auf den Z-Wert von P010 addierst du dann die 100mm.


    Dann fährst du auf P010, was die Position 100mm über dem Punkt ist.
    Diese Position speicherst du nun in P010 als Pulse.
    Nun hast du beide Positionen in Pulse-Koordinaten


    Im Programm brauchst du die Punkte nur noch anfahren.


    MOVL P010
    MOVL P011
    MOVL P010




    C - das sind die Geteachten Positionen in Pulse, welche du direkt im Programm gespeichert hast und nicht in einer P-Variable.


    Ich hoffe das hift dir weiter


    Daniela

    Hallo Dani,


    danke erstmal.


    Mir gehts hauptsächlich darum das ich nur einen Punkt teachen will.


    Wenn ich dich richtig verstanden habe, teache ich mir einen C-Punkt.
    Den lese ich dann in eine P-Variable ein und ändere den einen von den beiden.


    Jetzt hab ich da aber ein Verständnissproblem.
    wenn ich das C in einen P übernehme, hab ich das doch da auch als Pulse abgespeichert.
    Wenn ich das nu mit CONVRT umrechne ins BASE, kann ich den Z-Wert ändern.


    Kann ich nun den berechneten Punkt in einem Pulsejob überhaupt anfahren?
    Der ist ja nu nicht mehr in Pulsewerten vorhanden.


    Gruß
    Thadäus

    Hallo,


    was meinst du eigentlich mit Pulsejob. Der Roboter kann alle Positionen anfahren egal in welchem Koordinatensystem die Position gespeichert ist. Letztendlich werden die Koordinaten eh alle in Pulse-Werte umgerechnet, damit der Roboter weiß welche Achsen er wie bewegen muss.


    Warum willst du also alles komplett in Pulse machen?



    Um eine geteachte Position in eine P- Variable im Programm einzulesen muss man das mit Gets machen:


    Position anfahren


    GETS P001 $PX000 --> aktuelle Position wird als PULSE in P001 gespeichert


    GETS P001 $PX001 --> aktuelle Position wird als X,Y,Z-Variable in P001 gespeichert



    Wenn du aber erst den Punkt über deinem geteachten Punkt anfahren willst,
    dann muss dieser Punkt schon in einer P-Variablen gespeichert sein.


    Wenn dieser dann als Pulse gespeichert ist, dann kannst du ihn mittels CONVRT in das BF umwandeln.


    CNVRT PX001 PX002 BF --> P002 wird in X,Y,Z-Koordinaten umgewandelt und in P001 gespeichert.




    noch eine Möglichkeit wäre die Shift-Methode, dazu


    speicherts du in deinem Programm 2 x hintereinander deinen geteachten Punkt.


    Vor den ersten kommt dann ein SFTON P020 BF --> in P020 ist Z= 100mm und der Rest 0
    Hinter den ersten kommt schließlich SFTOF



    Alles in allem benötigst du mindestens eine P-Variable.


    VG
    Daniela

    Hallo Thadäus,
    hier ein Beispiel wenn der Roboter mit einem
    geteachten Punkt auf der Startposition steht und in Z Richtung
    zuerst in – und in + verfährt.




    NOP
    MOVJ C00000 VJ=50.00 geteachte Position
    GETS PX000 $PX000 einlesen der Position
    CNVRT PX000 PX000 RF umwandeln in Roboterframe
    GETE D000 P000 (3) Z wert auslesen
    SUB D000 100000 100 mm subtrahieren
    SETE P000 (3) D000 Z wert setzen
    MOVL P000 V=83.3 Position anfahren
    ADD D000 100000 100 mm addieren
    SETE P000 (3) D000 Z wert setzen
    MOVL P000 V=83.3 Position anfahren
    END


    Achte darauf das du keine verwendeten Variablen benutzt !!!


    Gruß wieso

    Hallo,


    es gibt auch die Möglichkeit einen IMOV zu benutzen. Der IMOV Befehl fährt von der aktuellen position einen vorgegebenen Wert z.B 100mm nach oben oder (-100mm) nach unten.


    IMOV sthet in der INFORM Liste unter Bewegung


    Grüße,
    Minimann

    Danke euch, da wird schon einiges klarer.


    jetzt nur noch drei Kleinigkeiten.


    1. Das mit dem Pulsejob, das ist vielleicht einfach was von mir falsch Verstandenes.
    Mir hat man gesagt, ich muss das ganze in einem nicht Relativjob machen, das ist einfach so vorgabe, ob ich das will oder nicht. Wenn mir einer von euch kurz sagen könnte, was nun der Unterschied zwischen einem normalen Job und einem Relativjob ist, hab ich da wahrscheinlich auch endlich klare Sicht.


    2.Wann genau verwendet ihr ein P und wann ein PX? Bzw, was ist der Unterschied. Hab zwar die erklärum im Handbuch vor mir, aber irgendwie bleibt mir die unklar.


    3.Wie stelle ich sicher, das ich keine verwendeten Variablen benutze? Ich hätt jetzt für die Punkte LP-Variablen genommen, dann sind Sie doch lokal. Ich finde diese lokalen Variablen nur irgendwie in keinem Beispiel das ich habe. Gibt's bei deren Verwendung ein Problem?


    Wie auch immer, eine C-Variable muss ich ja nehmen, und die gibts nur global. (Stimmt das?) wie kann ich bei denen sicherstellen, dass ich keine verwendeten erwische.


    @Miniman:
    Ebenfalls danke. Auf die IMOV bin ich auch schon gestoßen, aber mit der kann ich ja nur von meinem aktuellem Punkt aus in eine Richtung fahren. Wenn ich das richtig sehe, hilft mir das nicht, wenn ich relativ zu einem bestimmten Punkt anhalten will, bevor ich zu diesem fahre.

    Einmal editiert, zuletzt von Thadäus ()

    Hallo,


    ja mit dem IMOV hast Du recht wenn ich das nochmal überdenke, dürfte das nicht funktionieren... War halt son Gedake.


    Zu 1. Bei Motoman sind alle Jobs Pulsejobs weil Motoman alle Positionen in Pulse abspeichert, die direkt vom Encoder kommen.
    In einem Relativjob beziehen sich die Positionen nicht auf die Pulse sondern auf z.B. Anwenderkoordinatensysteme. In einem Relativjob fährst Du z.B nach den Koordinaten die Du von einer Kamera bekommst, also relativ im Raum bezogen auf irgendein Frame.


    2. die P-Variable eine Positionsvariable des Roboters. Es gibt keinen Unterschied das PX verwendent man in manchen Befehlen z.B bei allen Berechnungen. Aber P000 und PX000 ist ein und das selbe.


    3. Lokamle Variablen musst Du zuerst im Jobhedar eintragen wie viele Du verwenden willst.
    Menü "Display" -> Job Header wähler und LP Variablen anwählen. Achtung! die kannst Du nur in diesem job verwenden!


    Ich denke Du meinst P Variable anstatt C??? P-Variablen gibt es nur Global ja das stimmt. Grundsätzlich kannst Du nur schwer vermeiden, dass Du die Variable überschreibst. Aber Du kannst z.B die P Variable beschriften unter Variablen P dann erinnerst Du Dich vielleicht daran :mrgreen:


    Ein Weg währe, dass Du Dir die P Varibable zu beginn des Jobs initialisierst z.B sub P000 P000 dann ist P000 = 0, oder Du liest Dir einen geteachten Punkt am Anfang des Jobs z.B GETS P000 $PX000 aktuelle Position in P000 einlesen.



    Grüße Minimann

    Hiho und danke.


    Ich meinte schon diese C-Dinger. So wie wieso sie verwendet hat und Dani sie weiter oben erklärt hat. (Nur sinds keine Variablen sondern geteachte Positionen, oder?) Wenn ich mit $PX000 auf die aktuelle Position abrfe, dann ist das die tatsächliche Position, an der der Roboter steht, oder? Ich will aber eigentlich die Position haben zum berechnen, bevor der Roboter diese anfährt, weil ich ja erst eine Relativbewegung bezogen auf diesen Punkt machen will, bevor ich in anfahre.


    Hier nehm ich dann das CONVRT, sehe ich das richtig?

    Hallo,


    ja diese "C Dinger" sind letztendlich die positionen deines geteachten Jobs. Das sind aber keine Variablen oder dergleichen die Du lesen berechnen oder sonstwas kannst.
    Die $P000 ist die aktuelle Position auf der dein Robi steht in Pulse.
    Das CNVRT benutzt Du wenn Du deine Koordinaten die Du in Pulse erhalten hast in Koordinaten umrechnen willst z.B Userframes, oder wie Wieso ins Robotframe.
    Aber das was Du brauchst um deine Relativbewegung zu machen hat Wieso ja bereits perfekt beschrienben.


    Grüße Minimann

Erstelle ein Benutzerkonto oder melde dich an um zu kommentieren

Du musst ein Benutzerkonto haben um einen Kommentar hinterlassen zu können

Benutzerkonto erstellen
Neues Benutzerkonto für unsere Community erstellen. Geht einfach!
Neues Benutzerkonto erstellen
Anmelden
Du hast bereits ein Benutzerkonto? Melde dich hier an.
Jetzt anmelden