16. Juni 2019, 05:17:44
Roboterforum.de - Die Industrieroboter- Anwender und Experten Community

[Info] Lösungsansatz KUKA Bewegungsbefehle flexibler zu gestalten


normal_post Autor Thema: [Info] Lösungsansatz KUKA Bewegungsbefehle flexibler zu gestalten  (Gelesen 1583 mal)

0 Mitglieder und 1 Gast betrachten dieses Thema.

28. Juni 2017, 12:47:35
Gelesen 1583 mal
Offline

MaBo


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:

&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

Dann das DAT File:
&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
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.
« Letzte Änderung: 28. Juni 2017, 13:02:10 von MaBo »
  • gefällt mir    Danke
Man muss nicht Verrückt sein, aber es hilft ungemein.
Meine Roboter verspeisen SPS-Programmierer zum Frühstück.
Lass niemals einen Dipl. Ing. an den Roboter, die machen immer alles kaputt und sind viel zu Banane im Kopf.

Heute um 05:17:44
Antwort #1

Werbung

Gast

28. Juni 2017, 14:20:35
Antwort #1
Offline

drudge


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,
  • was im Detail stört dich (in welchen Situationen)
  • und wie würdest du es gerne haben?
  • gefällt mir    Danke

29. Juni 2017, 11:47:05
Antwort #2
Offline

MaBo


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.


  • gefällt mir    Danke
Man muss nicht Verrückt sein, aber es hilft ungemein.
Meine Roboter verspeisen SPS-Programmierer zum Frühstück.
Lass niemals einen Dipl. Ing. an den Roboter, die machen immer alles kaputt und sind viel zu Banane im Kopf.

30. Juni 2017, 14:11:17
Antwort #3
Offline

drudge


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):
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.


;--- 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
  • gefällt mir    Danke

03. Juli 2017, 21:24:17
Antwort #4
Offline

MaBo


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
  • gefällt mir    Danke
Man muss nicht Verrückt sein, aber es hilft ungemein.
Meine Roboter verspeisen SPS-Programmierer zum Frühstück.
Lass niemals einen Dipl. Ing. an den Roboter, die machen immer alles kaputt und sind viel zu Banane im Kopf.

Heute um 05:17:44
Antwort #5

Werbung

Gast

04. Juli 2017, 22:21:07
Antwort #5
Offline

drudge


sollte mit dem Roboter dabei sein ... KSS V8.3 Betriebsanleitung für Systemintegratoren (PDF)
  • gefällt mir    Danke

14. Juni 2019, 10:36:58
Antwort #6
Offline

19Rico84


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

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
« Letzte Änderung: 14. Juni 2019, 10:48:32 von 19Rico84 »
  • gefällt mir    Danke


Teile per facebook Teile per linkedin Teile per pinterest Teile per reddit Teile per twitter
 

über das Roboterforum

Nutzungsbedingungen Impressum Datenschutzerklärung

Sponsoren des Roboterforums

ROBTEC GmbH