Grundsatzfrage Genauhalt und Programmvorlauf

JxRx · 17. Oktober 2022

Hallo zusammen.

Als Umsteiger von ABB nach Kuka habe ich in diesem Forum schon Antworten auf so einige Fragen gefunden (danke dafür). Jetzt stehe ich jetzt vor einem Rätsel, zu dem ich noch nichts gefunden habe; wahrscheinlich, weil es für Kuka- Erfahrene selbstverständlich ist.

Ich habe eine grundsätzliche Frage zum Verhalten des Programms, speziell des Programmvorlaufes bei einem Genauhalt.

Edit: es geht um KSS 8.5 und KSS 8.6
Es geht um ein Programm nach folgendem Muster:

;FOLD SLIN p4 Vel=0.1 m/s CPDAT51 Tool[1] Base[1]
intVariable=4

;FOLD SLIN p3 Vel=0.1 m/s CPDAT51 Tool[1] Base[1]
intVariable=3

;FOLD SLIN p2 Vel=0.1 m/s CPDAT51 Tool[1] Base[1]
intVariable=2

;FOLD SLIN p1 Vel=0.1 m/s CPDAT51 Tool[1] Base[1]
intVariable=1

Da alle Punkte als Genauhalt programmiert sind (ohne CONT) hätte ich erwartet, das die Änderung der Variable jeweils nach Abschluss der Bewegung erfolgt.
Also: Bewegung nach P4, intVariable=4, Bewegung nach P3, intVariable=3, Bewegung nach P2, intVariable=2 usw., wie ich es z.B. von ABB gewohnt bin.

Tatsächlich ist es so, dass die Variable direkt nach dem Start einen Wert "weiter unten" annimmt, also offensichtlich im Programmvorlauf geändert wird. Die Bewegung stoppt brav an jedem Punkt.

Dazu meine Frage: Ist es normal, das ein Genauhalt keinen Vorlaufstopp erzeugt, oder gibt es dazu eine Konfigurationsmöglichkeit?

TIA,

Jochen

Jonas315 · 17. Oktober 2022

Hallo Jochen,

normalerweise ist der Ablauf bei einem Genauhalt genauso wie du Ihn beschrieben hast, die folgende Anweisung wird erst nach Erreichen des Punktes ausgeführt.

Zur Fehleranalyse wäre also ein richtiger Programmausschnitt hilfreich.

Um eine Anweisung Bewegungsabhängig zu machen gäbe es übrigens noch den sog. "TRIGGER", damit lässt sich deklarieren wann eine Anweisung in Bezug zu der folgenden Bewegung ausgeführt wird (Start, Ende, Zeit, Distanz).

Bsp

TRIGGER WHEN DISTANCE = 1 DELAY = 0 DO int=1

Beim Erreichen des Bewegungspunktes (Distance = 1, 0 wäre bei Start der Bewegung, Delay gibt einen Offset in Sekunden an) setze die Variable "int" auf 1. Auch Funktionen oder Unterprogramme lassen sich so ausführen.

____________

EDIT

Bei Trigger When Distance ist der Delay zeitlich und bei Trigger on Path ist der Delay über die Distanz

kasperkopp · 17. Oktober 2022

Hallo JxRx

Einfache Antwort Ja ... und Ja

Den Vorlauf kannst du über dei Variable $ADVANCE beeinflussen. Der steht Standardmäßig auf 3, in deinem Fall auf 0 setzen und er geht Zeile für Zeile durch, danach wieder auf 3.

Du könntes auch TRIGGER ON PATH benutzen (SYN OUT) wobei du hier noch die Schaltpunkte beeinflussen könntest (+/- mm). Oder du nutzt Trigger TRIGGER WHEN DISTANCE, wobei hier 0 bedeutet, wird gesetzt sobald du den Punkt anfährst und 1 wenn der Punkt erreicht ist.

Die "dreckige" Lösung wäre einfach vor der Variablenzuweisung ein WAIT SEC 0 oder WAIT FOR TRUE (löst einen Vorlaufstop aus)

Gruß Kasperkopp

EDIT: ... war wohl jemand schneller ...

Programmiersklave · 17. Oktober 2022

Die meisten Programmierer plagen sich mit dem entgegengesetzten Problem.

Die Tatsache, dass man keinen Überschleifparameter hat, hält die Steuerung nicht davon ab, schon mal die nächsten Bewegungen zu planen. Man muss stattdessen zusätzlich tatsächlich den Vorlauf anhalten.

Beim ABB ist das undefinierter, dort weiß man eigentlich grundsätzlich nicht, wo der Vorlaufzeiger gerade ist (beim Kuka ist das besser berechenbar), wehalb man sich bei "fine"-Punkten dort auch an einem Vorlaufstopp erfreuen kann.

JxRx · 17. Oktober 2022

Hm, das sind ja zwei relativ unterschiedliche Antworten.

Zitat von Jonas315

normalerweise ist der Ablauf bei einem Genauhalt genauso wie du Ihn beschrieben hast, die folgende Anweisung wird erst nach Erreichen des Punktes ausgeführt.

Zitat von kasperkopp

Einfache Antwort Ja ... und Ja

Die Triggerbefehle sind mir bekannt. Damit wird im Hauptablauf für die Grundstellungsfahrt mitgezählt, wo sich der Roboter befindet. Übliches und bekanntes Vorgehen, denke ich.

Da ich im Grundstellungsprogramm alles mit Genauhalt fahre hatte ich gedacht, ich könnte mir das Leben mit einfachen Zuweisungen leichter machen. Für den Fall, das das nicht geht werde ich wohl die semidreckige Lösung wählen und ein UP mit "wait for false" und Zuweisung bauen. (Seitdem ich hier im Forum gelernt habe wie man ein KUKA Program NOSTEPIN macht finde ich das auch nicht mehr ganz so gruselig).

$Advance hatte ich auch schon mal gelesen, möchte ich aber nicht ohne Not zur Laufzeit dran rumfummeln. Im Hauptablauf ist Überschleifen natürlich erwünscht.

Vor dem Posten eines Programmauschnitts war ich zurückgeschreckt, weil jede Menge dieser Inlineformulare genutzt werden. Aber vllt. hilft es ja:

Code

if CTR_Homing > 0 then


   ; SAK-FAHRT


$BWDSTART = FALSE


PDAT_ACT = PPDAT36


FDAT_ACT = FpNachGrpR3


   BAS(#PTP_PARAMS, 100.0)


   SET_CD_PARAMS (0)


   ptp $POS_ACT




   while CTR_Homing > 0




      switch CTR_Homing

case 2001


;FOLD SLIN pC20_VorAbl2NioTeilL Vel=0.5 m/s dHome Tool[1]:Greifer1 Base[20]:Cell-20 ;%{PE}


   ;FOLD Parameters ;%{h}


      ;Params IlfProvider=kukaroboter.basistech.inlineforms.movement.spline; Kuka.IsGlobalPoint=False; Kuka.PointName=pC20_VorAbl2NioTeilL; Kuka.BlendingEnabled=False; Kuka.MoveDataName=dHome; Kuka.VelocityPath=0.5; Kuka.VelocityFieldEnabled=True; Kuka.ColDetectFieldEnabled=True; Kuka.CurrentCDSetIndex=0; Kuka.MovementParameterFieldEnabled=True; IlfCommand=SLIN


   ;ENDFOLD


   SLIN XpC20_VorAbl2NioTeilL WITH $VEL = SVEL_CP(0.5, , LdHome), $TOOL = STOOL2(FpC20_VorAbl2NioTeilL), $BASE = SBASE(FpC20_VorAbl2NioTeilL.BASE_NO), $IPO_MODE = SIPO_MODE(FpC20_VorAbl2NioTeilL.IPO_FRAME), $LOAD = SLOAD(FpC20_VorAbl2NioTeilL.TOOL_NO), $ACC = SACC_CP(LdHome), $ORI_TYPE = SORI_TYP(LdHome), $APO = SAPO(LdHome), $JERK = SJERK(LdHome), $COLLMON_TOL_PRO[1] = USE_CM_PRO_VALUES(0)


;ENDFOLD


ctr_homing=2000




         case 2003,2002


            Gripper1(#WP)


;FOLD SLIN pC20_VorAbl1NioTeilL Vel=0.3 m/s dHome Tool[1]:Greifer1 Base[20]:Cell-20 ;%{PE}


   ;FOLD Parameters ;%{h}


      ;Params IlfProvider=kukaroboter.basistech.inlineforms.movement.spline; Kuka.IsGlobalPoint=False; Kuka.PointName=pC20_VorAbl1NioTeilL; Kuka.BlendingEnabled=False; Kuka.MoveDataName=dHome; Kuka.VelocityPath=0.3; Kuka.VelocityFieldEnabled=True; Kuka.ColDetectFieldEnabled=True; Kuka.CurrentCDSetIndex=0; Kuka.MovementParameterFieldEnabled=True; IlfCommand=SLIN


   ;ENDFOLD


   SLIN XpC20_VorAbl1NioTeilL WITH $VEL = SVEL_CP(0.3, , LdHome), $TOOL = STOOL2(FpC20_VorAbl1NioTeilL), $BASE = SBASE(FpC20_VorAbl1NioTeilL.BASE_NO), $IPO_MODE = SIPO_MODE(FpC20_VorAbl1NioTeilL.IPO_FRAME), $LOAD = SLOAD(FpC20_VorAbl1NioTeilL.TOOL_NO), $ACC = SACC_CP(LdHome), $ORI_TYPE = SORI_TYP(LdHome), $APO = SAPO(LdHome), $JERK = SJERK(LdHome), $COLLMON_TOL_PRO[1] = USE_CM_PRO_VALUES(0)


;ENDFOLD


ctr_homing=2001




         case 2004,2005


            Gripper1(#HP)


;FOLD SLIN pC20_NachAbl1NioTeilL Vel=0.5 m/s dHome Tool[1]:Greifer1 Base[20]:Cell-20 ;%{PE}


   ;FOLD Parameters ;%{h}


      ;Params IlfProvider=kukaroboter.basistech.inlineforms.movement.spline; Kuka.IsGlobalPoint=False; Kuka.PointName=pC20_NachAbl1NioTeilL; Kuka.BlendingEnabled=False; Kuka.MoveDataName=dHome; Kuka.VelocityPath=0.5; Kuka.VelocityFieldEnabled=True; Kuka.ColDetectFieldEnabled=True; Kuka.CurrentCDSetIndex=0; Kuka.MovementParameterFieldEnabled=True; IlfCommand=SLIN


   ;ENDFOLD


   SLIN XpC20_NachAbl1NioTeilL WITH $VEL = SVEL_CP(0.5, , LdHome), $TOOL = STOOL2(FpC20_NachAbl1NioTeilL), $BASE = SBASE(FpC20_NachAbl1NioTeilL.BASE_NO), $IPO_MODE = SIPO_MODE(FpC20_NachAbl1NioTeilL.IPO_FRAME), $LOAD = SLOAD(FpC20_NachAbl1NioTeilL.TOOL_NO), $ACC = SACC_CP(LdHome), $ORI_TYPE = SORI_TYP(LdHome), $APO = SAPO(LdHome), $JERK = SJERK(LdHome), $COLLMON_TOL_PRO[1] = USE_CM_PRO_VALUES(0)


;ENDFOLD


ctr_homing=2006


(jede Menge weitere Positionen gesnippt)



case 1


            CheckRotpose()


;FOLD SPTP fpRotpos0 Vel=20 % dHome Tool[10]:Grp1Corr Base[0] ;%{PE}


   ;FOLD Parameters ;%{h}


      ;Params IlfProvider=kukaroboter.basistech.inlineforms.movement.spline; Kuka.IsGlobalPoint=False; Kuka.PointName=fpRotpos0; Kuka.BlendingEnabled=False; Kuka.MoveDataPtpName=dHome; Kuka.VelocityPtp=20; Kuka.VelocityFieldEnabled=True; Kuka.ColDetectFieldEnabled=True; Kuka.CurrentCDSetIndex=0; Kuka.MovementParameterFieldEnabled=True; IlfCommand=SPTP


   ;ENDFOLD


   SPTP XfpRotpos0 WITH $VEL_AXIS[1] = SVEL_JOINT(20.0), $TOOL = STOOL2(FfpRotpos0), $BASE = SBASE(FfpRotpos0.BASE_NO), $IPO_MODE = SIPO_MODE(FfpRotpos0.IPO_FRAME), $LOAD = SLOAD(FfpRotpos0.TOOL_NO), $ACC_AXIS[1] = SACC_JOINT(PdHome), $APO = SAPO_PTP(PdHome), $GEAR_JERK[1] = SGEAR_JERK(PdHome), $COLLMON_TOL_PRO[1] = USE_CM_PRO_VALUES(0)


;ENDFOLD


;FOLD SPTP HOME Vel=20 % DEFAULT ;%{PE}


;FOLD Parameters ;%{h}


;Params IlfProvider=kukaroboter.basistech.inlineforms.movement.spline; Kuka.IsGlobalPoint=False; Kuka.PointName=HOME; Kuka.BlendingEnabled=False; Kuka.MoveDataPtpName=DEFAULT; Kuka.VelocityPtp=20; Kuka.VelocityFieldEnabled=True; Kuka.ColDetectFieldEnabled=True; Kuka.CurrentCDSetIndex=0; Kuka.MovementParameterFieldEnabled=True; IlfCommand=SPTP


;ENDFOLD


SPTP XHOME WITH $VEL_AXIS[1] = SVEL_JOINT(20.0), $TOOL = STOOL2(FHOME), $BASE = SBASE(FHOME.BASE_NO), $IPO_MODE = SIPO_MODE(FHOME.IPO_FRAME), $LOAD = SLOAD(FHOME.TOOL_NO), $ACC_AXIS[1] = SACC_JOINT(PDEFAULT), $APO = SAPO_PTP(PDEFAULT), $GEAR_JERK[1] = SGEAR_JERK(PDEFAULT), $COLLMON_TOL_PRO[1] = USE_CM_PRO_VALUES(0)


;ENDFOLD


CTR_HOMING = 0


         default


            ;Bei nicht programmierter Nummer Roboter anhalten


plcoMessageNo = 14


            msgquit("Grundstellungsfahrt fehlerhaft, ungueltiger GRST-Zaehler: %1","TypeHoming",CTR_Homing,,666,)


            wait for false


      endswitch




   endwhile


ENDIF

Alles anzeigen

EricH · 17. Oktober 2022

Du willst eine Homing-Fahrt machen. Würde ich definitiv Trigger dafür benutzen.

panic mode · 17. Oktober 2022

Fuer Homing-Fahrt Geschwindikgeit ist normalerwsiese kein Problem. Da alle Punkte als Genauhalt programmiert sind (ohne CONT), INT Variable konte auch als SIGNAL deklariert um VL Stop ausloesen. Oder $ADVANCE auf 0 setzen... Oder am liebsten Trigger einsetzen.

JxRx · 20. Oktober 2022

Zitat von panic mode

INT Variable konte auch als SIGNAL deklariert um VL Stop ausloesen.

Das klingt nach einer Todsünde, für die ich von den Kollegen gesteinigt würde- und für die ich die Kollegen steinigen würde.

Aber als schnelle Rettung ohne das Programm ändern zu müssen funktioniert das sogar, danke für den Tipp.

Edit: Da es hier im Faden unterschiedliche Aussagen zum Verhalten des Roboters gibt: Ein Bewegungsbefehl erzeugt bei Kuka grundsätzlich keinen Vorlaufstopp.

Ich baue mir für die Zuweisungen jetzt ein UP, in dem der Vorlaufstopp ausgelöst wird. Das bekomme ich mit vertretbarem Aufwand und Suchen/Ersetzen in die vorhandenen Programme. In Zukunft werde ich mehr auf Trigger setzen.

Danke an alle

Hermann · 20. Oktober 2022

Zitat von JxRx

Ich baue mir für die Zuweisungen jetzt ein UP, in dem der Vorlaufstopp ausgelöst wird. Das bekomme ich mit vertretbarem Aufwand und Suchen/Ersetzen in die vorhandenen Programme. In Zukunft werde ich mehr auf Trigger setzen.

Ist doch total einfach mit Suchen / Ersetzen auf Trigger umzustellen. Dazu musst allerdings einen externen Editor wie Notepad++ oder Ultraedit, der reguläre Ausdrücke beherrscht, verwenden.

Da kann man dann in deinem Beispiel nach

intvariable=([0-9]*)

suchen und durch

trigger when distance=0 delay=0 do intvariable=\1

ersetzen.

Lohnt sich wirklich, sich mal mit regulären Ausdrücken auseinanderzusetzen. Damit kann man oft geniale Sachen machen, die einem massig Zeit sparen.

Hab' so zum Beispiel schon mal ein funktionierendes Comau-Programm komplett auf Kuka, und diverse Kuka-Programme auf ABB umgesetzt, ohne die Funktionsweise der Programme komplett verstanden zu haben.

JxRx · 20. Oktober 2022

Zitat von Hermann

Ist doch total einfach mit Suchen / Ersetzen auf Trigger umzustellen. Dazu musst allerdings einen externen Editor wie Notepad++ oder Ultraedit, der reguläre Ausdrücke beherrscht, verwenden.

Die regulären Ausdrücke um meine Zuweisungen per NP++ in den UP-Aufruf um zu wandeln habe ich mir zeigen lassen, klappt prima. Den Triggerbefehl müsste ich ja noch von "nach der Bewegung" nach "vor der Bewegung" verschieben...

Zitat von Hermann

Lohnt sich wirklich, sich mal mit regulären Ausdrücken auseinanderzusetzen. Damit kann man oft geniale Sachen machen, die einem massig Zeit sparen.

Definitiv. Ist auf der Agenda wieder ein paar Plätze nach oben gerutscht,,,

Hermann · 20. Oktober 2022

Zitat von JxRx

Den Triggerbefehl müsste ich ja noch von "nach der Bewegung" nach "vor der Bewegung" verschieben...

Auch das sollte mit den regulären Ausdrücken machbar sein!

Grundsatzfrage Genauhalt und Programmvorlauf

Erstelle ein Benutzerkonto oder melde dich an um zu kommentieren

Gebrauchtroboter kaufen - Was ist zu beachten. Die Checkliste zum kauf von gebrauchten Robotern

Was macht ein Roboterprogrammierer genau und was verdient er?

Vernetzen, referenzieren, kollaborieren: Das B2B Portal für die Produktionsautomatisierung

Sie wollen Ihr Stellenangebot im Roboterforum schalten? Ab 149€

Werde Roboterprogrammierer bei ROBTEC GmbH in Mainburg / Bayern

Teilen

Tags

Wieviele Mitglieder waren heute eingeloggt?