Beiträge von MaBo

Hi,

geh in die $config.dat und schreib ganz unten in etwa so:

SIGNAL MeineZahl $IN[1] To $IN[5]

Dann bildet dir das System eine Zahl.

Hi Leute,

ich suche gerade eine Möglichkeit eine Steuerung eindeutig identifizieren zu können um das Programm an diese koppeln zu können. Leider ist ja die Seriennummer in der MOC änderbar, weshalb das nicht weiterhilft.
Gibt es die Möglichkeit z. B. die MAC Adresse eines Netzwerkadapters oder die ID des SMB Boards aus Rapid heraus auszulesen, um eine Steuerung bzw. Roboter eindeutig identifizieren zu können.

Es soll verhindert werden das ein Programm fälschlicherweise auf eine andere Steuerung gelangt und dort womöglich Schaden anrichtet.

Gruss Matze

Hi,
Danke für die Tipps. Das Probiere ich gleich mal aus.

Hi,

ja daran hab ich auch schon gedacht. Aber ich wollte jetzt nicht jede Position anfahren und dann neu speichern. Zumal ich nicht weiß ob ich da ein wenig an Genauigkeit verliere.

Hi Leute,
ich suche eine Möglichkeit eine Position (robtarget) das in einem Werkobjekt definiert ist rechnerisch auf ein anderes Werkobjekt zu übertragen, ohne das es sich Räumlich ändert. Also nicht einfach das robtarget mit einem anderem Werkobjekt anfahren. Da würde die Position nicht mehr an der selben Stelle sein, sondern Rechnerisch auf ein anderes Werkobjekt übertragen.

Ich denke irgendwie das Werkobjekt herrausrechnen und im Anschluss das neue herreinrechnen.

Habt Ihr das schonmal gemacht oder gibt es in Rapid eine Funktion dafür?

z. Beispiel:

newRobtarget:=Function(oldRobtarget,oldWorkobject,newWorkobject);

Vielen Dank schon mal für eure Mühe.

Hi,
gibt es bei KUKA eine Möglichkeit REAL Zahlen zu Runden so das sie keine Nachkommastellen mehr haben oder diese gar abzuschneiden. Oder gibt es irgend einen anderen Trick. Ich weiß bei ABB gibt es z. B. die Funktion ROUND.

Vielen Dank

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

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.

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.

Ich würde mal schauen was für eine CPU von Siemens du hast, welche Bussysteme sie unterstützt. Andererseits kannst du mal schauen ob schon ein Controller für Profibus oder Profinet im KUKA verbaut ist.
Wenn für dich eine hohe Performance - Übertragungsrate entscheident ist, dann solltest du auf Profinet setzen.

Hi,
um jetzt vorhandenes zu verwenden ohne jetzt ein Tool oder sonstiges zu schreiben, könntest du 6 Analogeingänge definieren um Realzahlen zu übertragen (1. Eingang X Koordinate, 2. Eingang Y Koordinate, 3. Eingang Z Koordinate, 4. Eingang A Rotation, 5. Eingang B Rotation und 6. Eingang C Rotation). Das Ganze mit einem Toggle in ein Positions Registerarray schreiben z. B. im SPS Submit. Dann im Robotertask die Arrays einzeln anfahren.
Damit das Halbwegs funktioniert sollten mindestens 10 Positionen vorraus übertragen werden. Kommt auch darauf an wie schnell du das alles übertragen bekommst.
Das ganze kannst über Device Net machen. Hat der Kuka ja onboard. Wenn du Siemens verwenden willst, dann ist Profibus eine gute Wahl. Profinet ist denke ich auch möglich. Benötigt halt zusätzlich Controller Karten in der Kuka Steuerung.

Hi,
die Register bei Fanuc ist wohl den CNC Ingenieuren zu verdanken die aus einer CNC Steuerung eine Robotersteuerung gebastelt haben statt eine gescheite Programmiersprache wie Rapid bei ABB.
Im Grunde wird für dich bei ABB alles besser. Das deklarieren und benennen von Variablen (Fanuc nennt das Register) hast du viel mehr Freiheiten und vor allem keine Limits der Menge, wie bei Fanuc das der Fall ist. Auch der Speicher ist viiiiiiiiiieeeeel Grösser als bei Fanuc. Im Grunde hast du nur Vorteile.

Bei älteren Robot Ware ständen, ich glaub ab 5.15.2 und älter ist die .sxml Datei nicht bestandteil des Backups. Dort musst du sie über den Visualizer in das Home Verzeichnis kopieren lassen. Danach ist sie mit im Backup enthalten.

Das Problem kann ich nicht nachstellen.
Hab die Letzten Wochen mit IRB140, IRB2600, IRB6700 zu tun gehabt. Mal mit SafeMove Classic mal mit SafeMove Pro. Aber der Bremsentest hat keinerlei Probleme gemacht. Verwedet wurde Robotware 5.15, 6.02, 6.03, 6.04 - keine Auffälligkeiten.
Mal eine andere Frage. Hast du bei der IBN irgendwelche alte Konfigurationsdateien von älteren Anlagen reingewürgt. z. B. die MOC? Weil dann würde das auch so einiges erklären. Die sind teilweise nicht mehr abwärtskompatibel. Und das kann auch solche beschriebenen Auswirkungen haben.

Gruss Matze

Hi,

das geht wenn du auf deinem Roboter die Option Weltzonen verwendest. Dort kannst du dann deine Homepositionen auf verschiedenste Art und Weise überwachen und als Signal an deine SPS weiterleiten. Von Haus aus ist dort keine Fertige Überwachung vorgesehen.

Gruss Matze

Hi,
ich bin vermutlich späth drann dein Problem zu beantworten.

Folgendes solltest du bitte überprüfen. In welcher Stellung wird der Bremsentest durchgeführt, hängt die Hand des Roboter herunter oder ist sie Ausgestreckt? Also kann der Bremsentest Lastneutral durchgeführt werden oder nicht? Welche Werte hast du in der SafeMove konfiguration eingestellt? Sind es die Standard Werte oder hast du sie optimiert?

Ist die Überwachungsschwelle 0,02 Radiant und die Stillstandstoleranz 2,0 Radiant? Hast du externe Fremdachsen die den Bremsentest negativ beeinflussen können im Einsatz? Die Stillstandstoleranz kann man im Bedarfsfall auch ein wenig erhöhen, wenn vertretbar. Niemals den Bremsentest deaktivieren so lange SafeMove für eine Aktive Sicherheit verwendet wird.

Das Ausführen des Bremsentests, wurde ja weiter oben schon etwas erläutert, sollte niemals abgebrochen werden. Die Auswirkungen sind ja bekannt . Ganz schlecht ist es den Bremsentest im Editor über das Testmenü Routine aufrufen auszuführen. Immer den Bremsentest über eine Aurufende Routine (Proc Call) ausführen. (Warum könnte ich erklähren, würde aber den Rahmen sprengen.)
Probleme mit dem Bremsentest sind meistens durch den Inbetriebnehmer verursacht. Daher muss das ganze mit grösster Sorgfalt durchgeführt werden.

Gruss Matze

Hi,
du kannst natürlich mit Robot Studio 6.04 den alten SafeMove konfigurieren. Besser ist 6.04.01 da Fehlerbereinigt. Dazu natürlich den Visual SafeMove Konfigurator verwenden. Man muss sich umgewöhnen, aber es es geht. Alles was man benötigt ist da. Beim ersten mal öffnen kann eine Fehler Meldung aufpopen, das noch keine konfiguration existiert. Darauf hin eine neue anlegen und mit dem konfigurieren beginnen. Der Rest sollte bekannt sein.
Gruss Matze

Hi,

ihr kennt sicher doch den BAS( ) Aufruf in den KUKA Roboterprogrammen.

Beispiele:
BAS(#TOOL,1)
BAS(#BASE,4)

Gibt es dafür ne offizielle Doku? Und wenn ja, kann diese mir jemand bereitstellen?

Danke! Gruss Matze

Hi,

also ich habs hinbekommen. Aber dein Tip war nur die halbe Wahrheit. Man muss in allen Min und Max Feldern die gleichen Werte eintragen, sonst geht es nicht und das System erzeugt irgend einen Blödsinn.

Beispiel:
Maximum Logical Value = 180000
Maximum Physical Value = 180000
Maximum Physical Value Limit = 180000
Maximum Bit Value = 180000
Minimum Logical Value = -180000
Minimum Physical Value = -180000
Minimum Physical Value Limit = -180000
Minimum Bit Value = -180000

Wird das so ausgefüllt dann passt alles und die Sim Werte ebenso. Allerdings konnte ich keine Doku finden die das Erklährt. Die einzige Doku die ich in meiner Sammlung habe die etwas über Signal beschreibt sagt etwa soviel aus wie, ja wir können auch Signale.
Sehr schlaue Aussage!?

Hi Leutz,

ich plag mich mal wieder mit Analogwerten rum. Leider hat die Forumsuche nicht weiter geholfen.

Folgendes:
Kamera schickt Verdrehungswerte zwischen -180000 - 180000 Milligrad. Ich muss also durch 1000 dividieren um den echten Grad Wert zu erhalten.
Auf der Schnittstelle arbeite ich mit einen Doppelwort.
Ist bis hier hin auch kein Problem.

Mit Gruppen Eingängen geht es nicht, da ich nur Positive Zahlen erhalte. Das ganze als Analogeingang funktioniert.

Jetzt kommt der Haken. Da der Empangene Wert zurück gespiegelt werden soll muss dazu ein Passender Analogausgang definiert werden.
Wenn ich jetzt bei der Min und Max Wertanagabe in der Signalkonfiguration 0 stehen lass, dann kann ich den Wert über das Programm zurück Schicken.
Aber wenn man testweise ein Wert setzen möchte dann geht das nicht, weil ja 0 im Min und Max Wert Fenster stehen.
Wenn ich jetzt dort Minwerte und Maxwerte eintrage, dann scheint die Steuerung die Werte zu wandeln und es wird nicht mehr der Richtig Wert gesendet.

Gibt es irgend eine Vorgehensweise oder einige Dinge die beachtet werden müsssen bei der Grenzwert Festlegung. Hab schon etliches ausprobiert. Nur wenn 0 in den Minwert und Maxwert Fenstern stehen wird der Korreckte Wert gesendet.

Hat jemand ne Idee, oder liegt es am Montag morgen!?

Gruss Matze