Lösungsansatz KUKA Bewegungsbefehle flexibler zu gestalten

MaBo · 28. Juni 2017

Hallo an alle Roboterkollegen,

ich zerbreche mir seit einiger Zeit den Kopf wie man die Bewegungsbefehle im KUKA flexibler gestalten kann. Die Inlineformulare sind ja schön und Gut. Aber sie sind weit von einer Flexibilität entfernt, die man als Professioneller Programmierer gerne wünscht. Oft findet man dann auch Kuriose Lösungsansätze für Offset Berechnungen oder Bewegungsbefehl Lösungen.

Daher hab ich überlegt wie das ganze schöner und flexibler machbar ist. Da ich nicht nur KUKA Programmiere, sondern auch FANUC, ABB, Stäubli und Mitsubishi ist mir natürlich nicht entgangen das es auch professionellere Lösungen dazu gibt.
Das Programmbeispiel hier ist nur als Diskussionsgrundlage gedacht und keines wegs erprobt oder getestet. Kritik ist erwünscht, und vielleicht entwickelt sich dabei etwas was uns allen nützlich sein könnte.

Hier der erste Vorschlag. Schaut es euch an, und lasst uns darüber diskutieren.

Erst mal das SRC File:

Code

&ACCESS RVO1
&COMMENT Expert Move Instructions
DEF MoveInstr ( )
   DECL E6POS xP1={X 0.0,Y 0.0,Z 0.0,A 0.0,B 0.0,C 0.0,S 0,T 0,E1 0.0,E2 0.0,E3 0.0,E4 0.0,E5 0.0,E6 0.0}
   DECL E6POS xP2={X 0.0,Y 0.0,Z 0.0,A 0.0,B 0.0,C 0.0,S 0,T 0,E1 0.0,E2 0.0,E3 0.0,E4 0.0,E5 0.0,E6 0.0}

   ;--- Diese ist die erste Alpha Version einer flexiblern Ausfuehrung von Bewegungen unter KUKA
   ;--- Sie ist noch ungetestet und muss sich erst noch in der Praxis beweisen. 
   ;--- Fehler sind daher normal und muessen bei Entdecken behoben werden.

   ;--- Zwei Beispiele ohne Offset Berechnung 
   MoveJ (xP1,PD100,FD0000,Z100,TOOL01,BASE01)
   MoveL (xP1,LD1000,FD0000,FINE,TOOL01,BASE00)
   MoveC (xP1,XP2,LD1000,FD0000,FINE,TOOL01,BASE00)

   ;--- Zwei Beispiele mit Offset Berechnung
   MoveJ (OFFSET(XP1,0,0,200),PD100,FD0000,Z100,TOOL01,BASE01)
   MoveL (TOOLOFFS(XP1,-200,0,0),LD1000,FD0000,FINE,TOOL01,BASE00)

END
GLOBAL DEF MoveJ (xPoint:IN, PDData:IN, FDData:IN, rZone:IN, iTool:IN, iBase:IN )
   DECL E6POS xPoint
   DECL FDAT FDData
   DECL PDAT PDData
   DECL REAL rZone
   DECL INT iTool,iBase

   ;--- Werkzeug, Zone und Base laden wenn 0 oder groesser, andernfalls wird Werkzeug, Zone und Base aus dem FDAT/PDAT verwendet
   IF (iTool >= 0) THEN
      FDData.TOOL_NO = iTool
   ENDIF
   IF (iBase >= 0) THEN
      FDData.BASE_NO = iBase
   ENDIF
   IF (rZone >= 0) THEN
      IF (rZone > 100) THEN
         rZone=100
      ENDIF
      PDData.APO_DIST = rZone
   ENDIF

   ;--- PDAT und FDAT laden usw.
   $BWDSTART=FALSE
   PDAT_ACT = PDData
   FDAT_ACT = FDData
   BAS(#PTP_PARAMS,PDData.VEL)

   ;--- Bewegung ausfuehren
   IF (rZone < 0) THEN
      PTP xPoint
   ELSE
      IF (rZone >= 0) THEN
         PTP xPoint C_PTP
      ENDIF  
   ENDIF

END
GLOBAL DEF MoveL (xPoint:IN, LDData:IN, FDData:IN, rZone:IN, iTool:IN, iBase:IN )
   DECL E6POS xPoint
   DECL FDAT FDData
   DECL LDAT LDData
   DECL REAL rZone
   DECL INT iTool,iBase

   ;--- Werkzeug, Zone und Base laden wenn 0 oder groesser, andernfalls wird Werkzeug, Zone und Base aus dem FDAT/PDAT verwendet
   IF (iTool >= 0) THEN
      FDData.TOOL_NO = iTool
   ENDIF
   IF (iBase >= 0) THEN
      FDData.BASE_NO = iBase
   ENDIF
   IF (rZone >= 0) THEN
      IF (rZone > 300) THEN
         rZone=300
      ENDIF
      PDData.APO_DIST = rZone
   ENDIF

   ;--- PDAT und FDAT laden usw.
   $BWDSTART=FALSE
   LDAT_ACT = LDData
   FDAT_ACT = FDData
   BAS(#CP_PARAMS,LDData.VEL)

   ;--- Bewegung ausfuehren
   IF (rZone < 0) THEN
      LIN xPoint
   ELSE
      IF (rZone >= 0) THEN
         LIN xPoint C_DIS C_DIS
      ENDIF
   ENDIF

END
GLOBAL DEF MoveC (xCirc:IN, xPoint:IN, LDData:IN, FDData:IN, rZone:IN, iTool:IN, iBase:IN )
   DECL E6POS xPoint, xCirc
   DECL FDAT FDData
   DECL LDAT LDData
   DECL REAL rZone
   DECL INT iTool,iBase

   ;--- Werkzeug, Zone und Base laden wenn 0 oder groesser, andernfalls wird Werkzeug, Zone und Base aus dem FDAT/PDAT verwendet
   IF (iTool >= 0) THEN
      FDData.TOOL_NO = iTool
   ENDIF
   IF (iBase >= 0) THEN
      FDData.BASE_NO = iBase
   ENDIF
   IF (rZone >= 0) THEN
      IF (rZone > 300) THEN
         rZone=300
      ENDIF
      PDData.APO_DIST = rZone
   ENDIF

   ;--- PDAT und FDAT laden usw.
   $BWDSTART=FALSE
   LDAT_ACT = LDData
   FDAT_ACT = FDData
   BAS(#CP_PARAMS,LDData.VEL)

   ;--- Bewegung ausfuehren
   IF (rZone < 0) THEN
      CIRC xCirc, xPoint
   ELSE
      IF (rZone >= 0) THEN
         CIRC xCirc, xPoint C_DIS C_DIS
      ENDIF
   ENDIF

END
GLOBAL DEFFCT E6POS OFFSET (xOFFPOINT:IN, rX:IN, rY:IN, rZ:IN )
   DECL E6POS xOFFPOINT
   DECL FRAME fOFFS
   DECL REAL rX,rY,rZ

   fOFFS = [rX,rY,rZ,0,0,0]
   xOFFPOINT = fOFFS:xOFFPOINT

   RETURN(xOFFPOINT)
ENDFCT
GLOBAL DEFFCT E6POS TOOLOFFS (xOFFPOINT:IN, rX:IN, rY:IN, rZ:IN, rA:IN, rB:IN, rC:IN )
   DECL E6POS xOFFPOINT
   DECL FRAME fOFFS
   DECL REAL rX,rY,rZ,rA,rB,rC

   fOFFS = [rX,rY,rZ,rA,rB,rC]
   xOFFPOINT = xOFFPOINT:fOFFS

   RETURN(xOFFPOINT)
ENDFCT

Alles anzeigen

Dann das DAT File:

Code

&ACCESS RVO1
&COMMENT Expert Move Instructions
DEFDAT MoveInstr PUBLIC


;--- PTP PDATs 8.2.17
;DECL GLOBAL PDAT PD1={VEL 1.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD3={VEL 3.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD5={VEL 5.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD10={VEL 10.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD20={VEL 20.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD30={VEL 30.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD40={VEL 40.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD50={VEL 50.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD60={VEL 60.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD70={VEL 70.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD80={VEL 80.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD90={VEL 90.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}
;DECL GLOBAL PDAT PD100={VEL 100.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP}


;--- PTP PDATs 8.3.22
DECL GLOBAL PDAT PD1={VEL 1.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD3={VEL 3.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD5={VEL 5.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD10={VEL 10.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD20={VEL 20.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD30={VEL 30.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD40={VEL 40.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD50={VEL 50.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD60={VEL 60.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD70={VEL 70.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD80={VEL 80.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD90={VEL 90.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}
DECL GLOBAL PDAT PD100={VEL 100.0,ACC 100.0,APO_DIST 100.0,APO_MODE #CPTP,GEAR_JERK 50}


;--- LIN LDATs 8.2.17/8.3.22
DECL GLOBAL LDAT LD10={VEL 0.01,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD30={VEL 0.03,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD50={VEL 0.05,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD100={VEL 0.1,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD200={VEL 0.2,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD300={VEL 0.3,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD400={VEL 0.4,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD500={VEL 0.5,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD600={VEL 0.6,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD700={VEL 0.7,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD800={VEL 0.8,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD900={VEL 0.9,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD1000={VEL 1.0,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD1500={VEL 1.5,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD2000={VEL 2.0,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD2500={VEL 2.5,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}
DECL GLOBAL LDAT LD3000={VEL 3.0,ACC 100.0,APO_DIST 100.0,APO_FAC 50.0,AXIS_VEL 100.0,AXIS_ACC 100.0,ORI_TYP #VAR,CIRC_TYP #BASE,JERK_FAC 50.0,GEAR_JERK 50.0,EXAX_IGN 0}


;--- FDATs
DECL GLOBAL FDAT FD0000={TOOL_NO 0,BASE_NO 0,IPO_FRAME #BASE,POINT2[] " ",TQ_STATE FALSE}


;--- Konstanten fuer Werkzeuge
DECL GLOBAL CONST INT TOOL00=0
DECL GLOBAL CONST INT TOOL01=1
DECL GLOBAL CONST INT TOOL02=2
DECL GLOBAL CONST INT TOOL03=3
DECL GLOBAL CONST INT TOOL04=4
DECL GLOBAL CONST INT TOOL05=5
DECL GLOBAL CONST INT TOOL06=6
DECL GLOBAL CONST INT TOOL07=7
DECL GLOBAL CONST INT TOOL08=8
DECL GLOBAL CONST INT TOOL09=9
DECL GLOBAL CONST INT TOOL10=10
DECL GLOBAL CONST INT TOOL11=11
DECL GLOBAL CONST INT TOOL12=12
DECL GLOBAL CONST INT TOOL13=13
DECL GLOBAL CONST INT TOOL14=14
DECL GLOBAL CONST INT TOOL15=15
DECL GLOBAL CONST INT TOOL16=16


;--- Konstanten fuer Bases
DECL GLOBAL CONST INT BASE00=0
DECL GLOBAL CONST INT BASE01=1
DECL GLOBAL CONST INT BASE02=2
DECL GLOBAL CONST INT BASE03=3
DECL GLOBAL CONST INT BASE04=4
DECL GLOBAL CONST INT BASE05=5
DECL GLOBAL CONST INT BASE06=6
DECL GLOBAL CONST INT BASE07=7
DECL GLOBAL CONST INT BASE08=8
DECL GLOBAL CONST INT BASE09=9
DECL GLOBAL CONST INT BASE10=10
DECL GLOBAL CONST INT BASE11=11
DECL GLOBAL CONST INT BASE12=12
DECL GLOBAL CONST INT BASE13=13
DECL GLOBAL CONST INT BASE14=14
DECL GLOBAL CONST INT BASE15=15
DECL GLOBAL CONST INT BASE16=16


;--- Konstanten fuer Zonen
DECL GLOBAL CONST REAL FINE=-1.0
DECL GLOBAL CONST REAL Z0=0.3
DECL GLOBAL CONST REAL Z5=5.0
DECL GLOBAL CONST REAL Z3=3.0
DECL GLOBAL CONST REAL Z10=10.0
DECL GLOBAL CONST REAL Z20=20.0
DECL GLOBAL CONST REAL Z30=30.0
DECL GLOBAL CONST REAL Z40=40.0
DECL GLOBAL CONST REAL Z50=50.0
DECL GLOBAL CONST REAL Z60=60.0
DECL GLOBAL CONST REAL Z70=70.0
DECL GLOBAL CONST REAL Z80=80.0
DECL GLOBAL CONST REAL Z90=90.0
DECL GLOBAL CONST REAL Z100=100.0
DECL GLOBAL CONST REAL Z150=150.0
DECL GLOBAL CONST REAL Z200=200.0
DECL GLOBAL CONST REAL Z250=250.0
DECL GLOBAL CONST REAL Z300=300.0


ENDDAT

Alles anzeigen

Vielleicht hat jemand ja auch eine Möglichkeit das ganze zu testen und kann uns von seinen Erfahrungen zu berichten.

Grüsse Matze

Edit: Ich hätte ja gern alle Files hochgeladen. Aber irgendwas stimmt mit dem CMS hier nicht.

Drudge · 28. Juni 2017

Hallo MaBo,
das was du vorschlägst, sieht sehr nach ABB aus. Ich komme zwar aus der KUKA Ecke, habe aber nun schon ein paar Programme in RAPID geschrieben... Fazit: ich finde die ABB Art zu Programmieren nicht durchwegs besser und vor allem einengend durch alle diese geschlossenen Funktionen ...
Wenn jedoch ILF-Programmierung und KRL-Programmierung gemischt ist, dann kann es schon ein wenig umständlich werden. Da gebe ich dir recht.
Bezüglich deinem Vorschlag:

wieso willst du sämtliche Bewegungs und Frameparameter bei jedem Befehl übergeben? Reicht es nicht die Werte nur bei der Initialisierung und bei Änderungen zu laden?

deine Offsetgeschichte kannst du bei KUKA ganz einfach über den Doppelpunktoperator lösen ...

Kurz ich verstehe nicht ganz genau,
[list type=decimal]

was im Detail stört dich (in welchen Situationen)

und wie würdest du es gerne haben?

[/list]

MaBo · 29. Juni 2017

Hi,
ich kann deine Argumente verstehen. Bei Fanuc z. B. wird das auch so Praktiziert.
Dort muss ich vorweg das UTool und das UFrame angeben, da die Bewegungsbefehle diese Informationen nicht beinhalten. Das birgt allerdings die Gefahr, das wenn jemand eine Änderung am Programm vornimmt und dazu das Tool oder Frame oder sogar beides wechselt und dabei nicht sorfältig arbeitet das es dann zu Fehlern kommt. Leider erhalte ich häufig Support anrufe die auf solchen Fehlern beruhen.

Wenn ich aber mit jedem Fahrbefehl diese Information mitgebe, dann kann man solchen Problemen vorbeugen, und Änderungen am Programm von unerfahrenen Programmierern sind dadurch leichter realisierbar.

Zu deinem zweiten Punkt geb ich dir grundsätzlich Recht. Man könnte die geometrische Addition auch im Bewegungsbefehl machen. Da einige schwierigkeiten damit haben wie herum die Addition angeordnet werden muss um ein Tool Offset oder ein Frame Offset zu erhalten, schien die Lösung über eine Funktion vorteilhafter. Man erkennt am Namen der Funktion welche Offsetberechnung statt findet.

Zu deiner ersten Frage was mich stört ist die fehlende Flexibilität die die ILFs mit sich bringen. Ausserdem möchte ich vermeiden das man vor dem ausführen der Bewegung etliche Variablen befüllen muss bzw. Berechnungen durchführen muss bevor der eigentliche Bewegungsbefehl kommt. Mein Ziel ist es alles erforderliche in eine Zeile zu bekommen. Dadurch wirkt das Programm aufgeräumter und kann leichter gelesen werden. Und dennoch gewinne ich mehr flexibilität, so meine Zielsetzung.

Zu deiner zweiten Frage die teilweise schon Oben beantwortet habe. Soviel flexibilität bei der definition einer Bewegungsanweisung wie möglich mit dem Ziel das alle Parameter und Informationen mit einer Zeile realisierbar ist. Also auf Folds und ausschweifenden Parameterbehandlungen zu verzichten. Desshalb geeignete Datentypen die namentlich zeigen welche Einstellung getroffen werden und diese als Paramter beim Ausführen der Bewegung übergeben.

Drudge · 30. Juni 2017

hmm da sind wir wohl nicht überall der selben Meinung
was ich wissen wollte ist: was bedeutet für die Flexibilität in diesem konkreten Fall?

Wenn ich dich richtig verstehe, dann denke ich es gibt das schon was du willst (Allerdings erst ab KSS V8.3):

Code

SLIN Zielpunkt <WITH SysVar1 = Wert1 <, SysVar2 = Wert2, …, >> <C_SPL>
SCIRC Hilfspunkt, Zielpunkt <, CA Kreiswinkel> <WITH SysVar1 = Wert1 <,SysVar2 = Wert2 , … >> <C_SPL>
SPTP Zielpunkt <WITH SysVar1 = Wert1 <, SysVar2 = Wert2 , …>> <C_SPL>

Da kannst du alles in eine Zeile und in Variablen packen ... ganz ohne ILF.

Code

;--- Zwei Beispiele mit Offset Berechnung
   ;MoveJ (OFFSET(XP1,0,0,200),PD100,FD0000,Z100,TOOL01,BASE01)
   SPTP {x 0,y 0,z 200,a 0,b 0,c 0}:XP1 WITH $TOOL=TOOL_DATA[1], $BASE=BASE_DATA[1]


   ;MoveL (TOOLOFFS(XP1,-200,0,0),LD1000,FD0000,FINE,TOOL01,BASE00)
   SLIN XP1:{x -200,y 0,z 0,a 0,b 0,c 0} WITH $TOOL=TOOL_DATA[1], $BASE=$NULLFRAME

Das müsste eigentlich gehen mit Offsets ... wenn ichs richtig im Kopf habe.

greez

MaBo · 3. Juli 2017

Hi,

interessant die SLIN, SPTP und SCIRC Befehle. Gibt es dazu mehr informationen. Bin leider nicht mehr ganz auf dem neuesten Stand mit der KRC4.

Hast du eine vernünftige Doku dazu. Das muss ich mir mal näher anschauen.

Greez

Drudge · 4. Juli 2017

sollte mit dem Roboter dabei sein ... KSS V8.3 Betriebsanleitung für Systemintegratoren (PDF)

19Rico84 · 14. Juni 2019

Moin, ich wärme dieses Thema mal auf, da mir die Schreibweise des Offset / RelTool Verfahrens von Kuka sehr gegen den Strich geht...

ich bin zwar gerade erst am Anfang diese Funktion zu erstellen, aber beim aufrufen dieser werden die Platzhalter nicht so dargestellt, wie ich es gern hätte...

Zitat

GLOBAL DEF Offs(strMove[]:IN,strPunkt[]:IN,x:IN,y:IN,z:IN,a:IN,b:IN,c:IN,nGeschw:IN,nZone:IN,nTool:IN,nBase:IN)
DECL CHAR strMove[], strText[24],strPunkt[]
DECL INT nZone, nTool, nBase
DECL REAL x,y,z,a,b,c,nGeschw

;LIN {X 0.0,Y 0.0,Z 0.0,A 0.0,B 0.0,C 0.0}:Punktname C_DIS

SWITCH strMove
CASE L
;instructions1
CASE J
;instructions1
CASE C
;instructions1
DEFAULT
;instructions2
ENDSWITCH

END

Alles anzeigen

Wenn ich diese Funktion aufrufe, wird mir folgendes vorgeschlagen:

Offs(CHAR, CHAR, x, x, x, x, x, x, x, nZone, nZone, nZone)

Die Frage nun - wie bring ich ihm bei folgendes daraus zu machen:

Offs(Art, Punkt, x,y, z, a, b, c, Geschwindigkeit, Zone, Werkzeug, Base)

Vielen Dank im Voraus

MfG Rico

panic mode · 16. Juni 2019

Code

GLOBAL DEF Offs(Art:IN,Punkt:IN,x:IN,y:IN,z:IN,a:IN,b:IN,c:IN,nGeschw:IN,nZone:in,nTool:IN,nBase:IN,ueberschleif:in)   DECL CHAR Art   DECL E6POS Punkt   DECL INT nTool, nBase   DECL REAL x,y,z,a,b,c,nGeschw, ueberschleif   DECL FRAME Offset    BAS(#TOOL,nTool)   BAS(#BASE,nBase)   $APO.CDIS = ueberschleif   ; nZone ...?   Offset.X = x   Offset.Y = y   Offset.Z = z   Offset.A = a   Offset.B = b   Offset.C = c   SWITCH chrMove   CASE "l","L"	 BAS(#VEL_CP,nGeschw)     LIN Offset:Punkt C_DIS   CASE "p","P"	 BAS(#VEL_PTP,nGeschw)     PTP Offset:Punkt C_DIS   DEFAULT     HALT   ENDSWITCHEND

zB.

Code

Offs("L",xP1,0,0,100,0,0,0,0.5,2,1,4,0.5)

19Rico84 · 17. Juni 2019

Zitat von panic mode

Code

GLOBAL DEF Offs(Art:IN,Punkt:IN,x:IN,y:IN,z:IN,a:IN,b:IN,c:IN,nGeschw:IN,nZone:in,nTool:IN,nBase:IN,ueberschleif:in)   DECL CHAR Art   DECL E6POS Punkt   DECL INT nTool, nBase   DECL REAL x,y,z,a,b,c,nGeschw, ueberschleif   DECL FRAME Offset    BAS(#TOOL,nTool)   BAS(#BASE,nBase)   $APO.CDIS = ueberschleif   ; nZone ...?   Offset.X = x   Offset.Y = y   Offset.Z = z   Offset.A = a   Offset.B = b   Offset.C = c   SWITCH chrMove   CASE "l","L"	 BAS(#VEL_CP,nGeschw)     LIN Offset:Punkt C_DIS   CASE "p","P"	 BAS(#VEL_PTP,nGeschw)     PTP Offset:Punkt C_DIS   DEFAULT     HALT   ENDSWITCHEND

zB.

Code

Offs("L",xP1,0,0,100,0,0,0,0.5,2,1,4,0.5)

Alles anzeigen

Das "zone" sollte das Verschleifen sein - ich habe als erstes ABB kennengelernt und es hat sich somit eingebrannt.

Danke trotzdem für die Starthilfe, aber ich habe mich wahrscheinlich falsch ausgedrückt....

Ich meinte, wenn ich für meine Funktion den Befehl "Offs" eintippe und dann mit "tab" vervollständige, kommt

Zitat

Offs(CHAR, CHAR, x, x, x, x, x, x, x, nZone, nZone, nZone)

bei dir kommt:

Zitat

Offs(Art, Punkt, x, x, x, x, x, x, x, nTool, nTool, x)

ich würde aber gern

Zitat

Offs(Art, Punkt, x,y, z, a, b, c, Geschwindigkeit, Zone, Werkzeug, Base)

oder etwas in der Art als Snippet haben wollen um das nachträgliche ausfüllen zu erleichtern - falls es möglich ist.

Trotzdem vielen Dank für deine Mühe.

================================================================

Nachtrag:

ich hatte die Funktion immer in sich selbst aufgerufen - soll heißen, das das Snippet außerhalb folgendermaßen aussah:

Zitat

Offs(strMove, E6POS, REAL, REAL, REAL, REAL, REAL, REAL, REAL, nGeschw, nGeschw, REAL)

Eine Lösung welche nicht so optimal ist habe ich gefunden:

Wenn man die Variablen nicht in der Funktion deklariert, sondern in der config.dat werden sie so angezeigt, wie ich es gern hätte:

Zitat

Offs(Art, Punkt, x, y, z, a, b, c, nGeschw, nTool, nBase, ueberschleif)

Größter Nachteil an dieser Variante ist natürlich, das die Variablen dann persistent und global sind.

Falls jemanden noch etwas besseres einfällt, bitte gerne posten.

Vielen Dank im Voraus

Rico

panic mode · 17. Juni 2019

Zitat von 19Rico84

Ich meinte, wenn ich für meine Funktion den Befehl "Offs" eintippe und dann mit "tab" vervollständige, ....

Eingetippt? Wo genau...?

19Rico84 · 17. Juni 2019

Zitat von panic mode

Eingetippt? Wo genau...?

Danke für den Hinweis, KUKA wird mir immer unsympathischer

Es funktioniert trotz "GLOBAL" deklarierter Routine natürlich nur im gleichen Modul in welcher auch die Routine steht -.-

Oder gibt es noch etwas, was ich übersehen habe?

Sven Weyer · 17. Juni 2019

Hast Du auch eine dazugehörige .dat?
Wenn ja ist es des öfteren schon hilfreich gewesen (DEFDAT "NAME der dat" PUBLIC) der dat-Definition ein "PUBLIC" hinzuzufügen.

Gruß

Sven

19Rico84 · 17. Juni 2019

Zitat von Sven Weyer

Hast Du auch eine dazugehörige .dat?
Wenn ja ist es des öfteren schon hilfreich gewesen (DEFDAT "NAME der dat" PUBLIC) der dat-Definition ein "PUBLIC" hinzuzufügen.

Gruß

Sven

Es zeigt die Variablen wie ich es gern hätte, aber....

Ist das nicht technisch das gleiche? - Also Persistent und global verfügbar?

...mein Problem ist trotzdessen noch, das die Routine nicht in anderen Modulen per "tab-TAste" verfügbar ist - sie wird beim tippen noch nicht einmal vorgeschlagen im Gegensatz dazu, wenn ich sie im gleichen Modul einsetzen möchte.

MfG Rico

19Rico84 · 28. Juni 2019

Guten Tag liebe Community,

ich hatte in den letzten Tagen mit einem anderen Projekt zu tun und kann mich nun wieder diesem Thema widmen...

Zitat

GLOBAL DEF Offs(strMove[]:IN,strPunkt[]:IN,x_o:IN,y_o:IN,z_o:IN,a_o:IN,b_o:IN,c_o:IN,nGeschw:IN,nZone:IN,nTool:IN,nBase:IN)
DECL CHAR strText[24], strPunkt[],strMove
DECL INT nZone, nTool, nBase
DECL REAL x_o,y_o,z_o,a_o,b_o,c_o,nGeschw
DECL FRAME Offsetpunkt
Offsetpunkt = {X 0.0,Y 0.0,Z 0.0,A 0.0,B 0.0,C 0.0}

;LIN {X 0.0,Y 0.0,Z 0.0,A 0.0,B 0.0,C 0.0}:Punktname C_DIS

SWITCH strMove
CASE L
$TOOL = tool_data[nTool]
$BASE = base_data[nBase]
$APO.CDIS = nZone

$APO.CVEL = nGeschw ;Geschwindigkeit - REAL zu INT Wert wird bemängelt = nur PTP?
$APO.VEL = nGeschw ;Geschwindigkeit - Element "VEL" wurde nicht gefunden

Offsetpunkt = strPunkt[] ;überschreiben der ausgewählten E6POS auf ein FRAME - E6POS aus Funktion oben entnehmen
Offsetpunkt.X=Offsetpunkt.X + x_o
Offsetpunkt.Y=Offsetpunkt.Y + y_o
Offsetpunkt.Z=Offsetpunkt.Z + z_o
Offsetpunkt.A=Offsetpunkt.A + a_o
Offsetpunkt.B=Offsetpunkt.B + b_o
Offsetpunkt.C=Offsetpunkt.C + c_o
LIN Offsetpunkt C_DIS

Alles anzeigen

Die Kommentare sind die Fehler, welche WorkVisual meldet, bzw. Fehler (E6POS übertragen) bei welchen ich nicht weiß, wie man es lösen kann.

Falls Ihr bessere Vorschläge habt, würde ich diese gerne sehen wollen.

Vielen dank im Voraus und ein schönes Wochenende

MfG

Rico

SJX · 28. Juni 2019

Hallo Rico,

paar Anmerkungen dazu:

$TOOL = tool_data[nTool]
Aktiviert Lastdaten nicht. Aufruf via BAS (#Tool, nTool) würde auch dies beinhalten.

$APO.CVEL = nGeschw
$APO.VEL = nGeschw

Bei $APO.x geht's ja ums Überschleifen. Du meintest wahrscheinlich eher $vel.cp.
Orientierungsgeschwindigkeit kein Thema zum Beeinflussen?

Offsetpunkt = strPunkt[]
Einem Frame einen String so zuweisen geht nicht.
Wenn der String die Koordinaten beinhaltet, müsste man diesen mit SRead() umwandeln.

Gibt's ein spez. Grund, wieso Du diese in Strings handeln willst und nicht mit den vom System vorgesehenen Datentypen?

Gruss SJX

Robonator · 28. Juni 2019

Zitat von SJX

$TOOL = tool_data[nTool]
Aktiviert Lastdaten nicht. Aufruf via BAS (#Tool, nTool) würde auch dies beinhalten.

Das Tool über Bas(#Tool,X) zu ändern, löst das nicht einen Zeilenvorlaufstopp aus?

19Rico84 · 28. Juni 2019

Guten Tag und danke für die schnelle Antwort,

ich würde gern eine (für mich zumindest) einfache Variante des Offset-Verfahrens als Funktion programmieren, da es meiner Meinung nach sehr viel übersichtlicher und einfacher ist als die Variante von KUKA.

Zitat von SJX

Hallo Rico,

paar Anmerkungen dazu:

$TOOL = tool_data[nTool]
Aktiviert Lastdaten nicht. Aufruf via BAS (#Tool, nTool) würde auch dies beinhalten.

$APO.CVEL = nGeschw
$APO.VEL = nGeschw

Bei $APO.x geht's ja ums Überschleifen. Du meintest wahrscheinlich eher $vel.cp.
Orientierungsgeschwindigkeit kein Thema zum Beeinflussen?

Offsetpunkt = strPunkt[]
Einem Frame einen String so zuweisen geht nicht.
Wenn der String die Koordinaten beinhaltet, müsste man diesen mit SRead() umwandeln.

Gibt's ein spez. Grund, wieso Du diese in Strings handeln willst und nicht mit den vom System vorgesehenen Datentypen?

Gruss SJX

Alles anzeigen

Zum Punkt der Geschwindigkeit:
$vel.cp ist ja wahrscheinlich für LIN - ist es für PTP einfach: $vel.PTP ?

Zum Punkt Tool:
vom Befehl BAS (#Tool, nTool) wurde mir von einem KUKA Trainer abgeraten,...
Zitat:

Zitat

Toolauswahl nicht über BAS Modul, sondern korrekt über KRL:
$tool = tool_data[x] ;aktuelle TOOL/Base aus $config.dat
$base = base_data[x]

Deshalb hatte ich es so geschrieben wie im letzten Post und den Vorlaufstopp müsste man ja mit einem "Continue" abfangen können oder?

Zum Thema Punkt und String:
Da ich ja den Punktnamen über die Funktion als String übertragen möchte, also wirklich nur den Namen - wie muss ich dann weiter vorgehen um diesen Punkt in das Frame zu schreiben - oder gibt es eine einfachere Variante?

SJX · 28. Juni 2019

Zitat von Robonator

Das Tool über Bas(#Tool,X) zu ändern, löst das nicht einen Zeilenvorlaufstopp aus?

Schon mal studiert, wie es KUKA mit den ILF's handelt?
Und was dann abgeht bei den BAS-Funktionen? Und da geht's ja auch mit Überschleifen!

ILF:
BAS(#CP_PARAMS,2)

BAS:
CASE #CP_PARAMS
CP_DAT ( )
FRAMES ( )
VEL_CP (REAL_PAR )
TQMDETECTION ( )

FRAMES:
DEF FRAMES ( )
…….

;Set IPO_MODE, $TOOL and $LOAD
SET_IPO_MODE (FDAT_ACT.IPO_FRAME )
TOOL (FDAT_ACT.TOOL_NO )

Tool (……...):
DEF TOOL (TOOL_NO :IN )
INT TOOL_NO

IF (TOOL_NO<=0) THEN
IF TOOL_CORR_W_ON AND TOOL_CORR_ON THEN
$TOOL=TOOL_CORR_W:TOOL_CORR
ELSE
IF TOOL_CORR_ON THEN
$TOOL=TOOL_CORR
ELSE
IF TOOL_CORR_W_ON THEN
$TOOL=TOOL_CORR_W
ELSE
$TOOL=$NULLFRAME
ENDIF
ENDIF
ENDIF

IF $ADAP_ACC<>#NONE THEN
$LOAD.M=$DEF_L_M
$LOAD.CM=$DEF_L_CM
$LOAD.J=$DEF_L_J
ENDIF
ELSE
IF TOOL_CORR_W_ON AND TOOL_CORR_ON THEN
$TOOL=TOOL_CORR_W:TOOL_DATA[TOOL_NO]:TOOL_CORR
ELSE
IF TOOL_CORR_ON THEN
$TOOL=TOOL_DATA[TOOL_NO]:TOOL_CORR
ELSE
IF TOOL_CORR_W_ON THEN
$TOOL=TOOL_CORR_W:TOOL_DATA[TOOL_NO]
ELSE
$TOOL=TOOL_DATA[TOOL_NO]
ENDIF
ENDIF
ENDIF
IF $ADAP_ACC<>#NONE THEN
IF LOAD_DATA[TOOL_NO].M<0 THEN
$LOAD.M=$DEF_L_M
$LOAD.CM=$DEF_L_CM
$LOAD.J=$DEF_L_J
ELSE
$LOAD.M=LOAD_DATA[TOOL_NO].M
$LOAD.CM=LOAD_DATA[TOOL_NO].CM
$LOAD.J=LOAD_DATA[TOOL_NO].J
IF (($LOAD.M<>0) AND ($LOAD.J.X==0) AND ($LOAD.J.Y==0) AND ($LOAD.J.Z==0)) THEN
$LOAD.J=$DEF_L_J
ENDIF
ENDIF
ENDIF
ENDIF

CONTINUE
$ACT_TOOL=TOOL_NO
END
;ENDFOLD TOOL ()

Gruss SJX

d4nuu8 · 28. Juni 2019

Zitat von Robonator

Das Tool über Bas(#Tool,X) zu ändern, löst das nicht einen Zeilenvorlaufstopp aus?

Bei absolutgenauen Robotern ja, sonst nicht.

SJX · 28. Juni 2019

[quote author=d4nuu8 link=topic=14405.msgGuten Tag und danke für die schnelle Antwort,

ich würde gern eine (für mich zumindest) einfache Variante de75347#msg75347 date=1561712839]
Bei absolutgenauen Robotern ja, sonst nicht.
[/quote]

@d4nuu8:
Wenn Du den Code des BAS () studierst findet man kein Hinweis auf Deine These.
Auch Standard-ILF's verwenden diese und es wäre mir neu, wenn Du mit absolutgenauen Robotern und ILF's nicht verschleifen kannst mit Argument "Const" aktiviert.
Woher hast Du diesen Hinweis?

Gruss SJX

Lösungsansatz KUKA Bewegungsbefehle flexibler zu gestalten

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?