Welche EK ist aktiv?

    • Schritt für Schritt zum Roboterprofi!

    ...moinsens,


    solange deine Achsen synchron sind siehts wohl ehr schlecht aus, bei Asynchronen Achsen könntest du auf das Bitfeld $async_axis schaun.
    Ansonsten vor einer Kinematikumschaltung Flags setzen und diese auswerten.

    Die Abnahme von GOTO Anweisungen verhält sich reziprok zur Qualität einer Programmierung

    Danke, wäre auch nur zur Sicherheit gewesen.
    Der Postprozessor meines OLP schreibt den EK(...) selbstständig raus, allerdings muss ich hinterher (die Reihenfolge kann ich leider nicht ändern) von der Maschine noch was draufrechnen lassen. Also rufe ich 'ne Routine mit der Berechnung auf und mache den EK(...) noch einmal selbst. Hätte darin nur vergleichen wollen, ob das OLP und die Maschine von denselben Annahmen ausgehen, damit es nicht so laut knallt :???:


    Grüße,
    Michael

    Wenn ichs jetzt falsch verstanden habe: :nocheck:



    Ansonsten kannst du doch über $ACT_BASE die Basenummer auslesen und dann nachsehen, welche Achsen zu dieser externen Kinematik gehören?

    $ACT_BASE? Da steht nur "Nummer des aktuellen Base-Systems". Ne Nummer habe ich ja nicht. Ich rufe EK auf, übergebe den Index der aktuellen Kinematik (das ist die Zahl, die ich später eigentlich wissen will) und einen beliebigen Frame. Die internen Basedata sind da unbrauchbar.
    Hatte eher auf $ACT_EX_AX gehofft, aber da steht immer -1 drin. Warum, weiß ich nicht.


    Trotzdem danke und Grüße,
    Michael

    Hallo,


    um die gerade an einer externen Kinematik beteiligten Achsen herauszufinden schlage ich
    folgende Funktion vor. Habe dies allerdings nicht getestet und kann natürlich für nichts garantieren.


    DEFFCT INT GetAxis(BaseNr:IN)
    ; liefert die an einer mathematisch Kopplung beteiligten
    ; Achsen als Bitmuster zurueck:
    ; Bsp:
    ; Ret=1 ; E1 beteiligt
    ; Ret=2 ; E2 beteiligt
    ; Ret=3 ; E1 und E2 beteiligt
    ; Ret=7 ; E1,E2 und E3 beteiligt
    ;
    ; Aufruf
    ; SWITCH GetAxis($act_base)


    INT BaseNr
    DECL ESYS KinematikTyp
    DECL ET_AX UsedKinematik


    ;STRUC EX_KIN ESYS ET1,ET2,ET3,ET4,ET5,ET6 ;EXTERNE KINEMATIKEN-
    ;DECL EX_KIN $EX_KIN={ET1 #NONE,ET2 #NONE,ET3 #NONE,ET4 #NONE,ET5 #NONE,ET6 #NONE}
    ;EXTERNE KINEMATIKEN #NONE,#EASYS,#EBSYS,#ECSYS,#EDSYS,#EESYS,#EFSYS,#ERSYS


    ;DECL ET_AX $ET1_AX={TR_A1 #NONE,TR_A2 #NONE,TR_A3 #NONE} ;EXTERNE ACHSEN #NONE, #E1, #E2, #E3, #E4, #E5, #E6


    ; globale Funktion ab SW 5.6: ESYS K_TYPE(Base_Nr)
    KinematikTyp=Kinematik_TYPE (BaseNr) ; easys,ebsys,..ersys


    IF $EX_KIN.ET1==KinematikTyp THEN
    UsedKinematik=$ET1_AX
    ELSE
    IF $EX_KIN.ET2==KinematikTyp THEN
    UsedKinematik=$ET2_AX
    ELSE
    IF $EX_KIN.ET3==KinematikTyp THEN
    UsedKinematik=$ET3_AX
    ELSE
    IF $EX_KIN.ET4==KinematikTyp THEN
    UsedKinematik=$ET4_AX
    ELSE
    IF $EX_KIN.ET5==KinematikTyp THEN
    UsedKinematik=$ET5_AX
    ELSE
    IF $EX_KIN.ET6==KinematikTyp THEN
    UsedKinematik=$ET6_AX
    ELSE
    RETURN(0)
    ENDIF
    ENDIF
    ENDIF
    ENDIF
    ENDIF
    ENDIF


    RETURN(GetAchsen(UsedKinematik))


    ENDFCT
    ;-----------------------------------
    DEFFCT ESYS Kinematik_TYPE (BASE_NO :IN)
    INT BASE_NO, IDX
    IF BASE_NO > 0 THEN
    IDX=MACHINE_FRAME_DAT[BASE_NO].MACH_DEF_INDEX
    IF IDX > 0 THEN
    RETURN MACHINE_DEF[IDX].MECH_TYPE
    ENDIF
    ENDIF
    RETURN #NONE
    ENDFCT
    ;-----------------------------------
    DEFFCT INT GetAchsen(ActKin:IN)
    DECL ET_AX ActKin
    INT iRet


    iRet=GetET(ActKin.TR_A1)
    iRet=iRet B_OR GetET(ActKin.TR_A2)
    iRet=iRet B_OR GetET(ActKin.TR_A3)
    ENDFCT
    ;-----------------------------------
    DEFFCT INT GetET(TrafoAxis)
    DECL EAX TrafoAxis

    SWITCH TrafoAxis
    CASE #NONE
    RETURN(0)
    CASE #E1
    RETURN(1)
    CASE #E2
    RETURN(2)
    CASE #E3
    RETURN(4)
    CASE #E4
    RETURN(8)
    CASE #E5
    RETURN(16)
    CASE #E6
    RETURN(32)
    DEFAULT
    RETURN(0)
    ENDSWITCH
    ENDFCT



    Grüsse,


    Berrad

    Zitat


    $ACT_BASE? Da steht nur "Nummer des aktuellen Base-Systems". Ne Nummer habe ich ja nicht. Ich rufe EK auf, übergebe den Index der aktuellen Kinematik (das ist die Zahl, die ich später eigentlich wissen will) und einen beliebigen Frame. Die internen Basedata sind da unbrauchbar.


    Wann immer geteacht wird, wird doch auch immer nach der Base(nummer) gefragt. Base 17-22 sind ja immer für die externen Kinematiken reserviert. Bei unserem Posiflex z.B. ist 17 Seite 1 und 18 Seite 2. Da ich die Geschichten ja irgendwann mal definiert und vermessen habe, weiss ich ja, welche Achsen bei Kinematik 1 und 2, also Basenummer 17 und 18 gekoppelt sind. Wenn dann in $ACT_BASE die 17 drinsteht, weiss ich das bei uns die Zusatzachsen 1+2 gekoppelt sind.


    .... ich glaube aber mal, dass ich immer noch falsch liege.... :pfeif:

    Bis SW 4 gab es noch kein RoboTeam, da war alles noch relativ einfach.
    Base 1-16 waren lokal, Base 17-32 extern.
    Wie ich es verstanden habe, bechreiben nun die Variablen Machine_def,Machine_tool und
    Machine_frame den gesamten zellenaufbau.
    Es kann daher auch base1 eine externe Kinematik sein.


    Zu welchem Zweck diese Funktion benötigt wird, erschliesst sich mir auch nicht.
    Man könnte es sich ja auch vorher merken.


    Aber so ganz bin ich da auch noch nicht dahintergestiegen....

    Berrad:
    Danke für die Mühe! Allerdings habe ich keine BaseNr.
    Wenn ich Zeit habe, :???: werde ich noch ein wenig forschen in die Richtung.
    Der Sinn ist folgender (falls es wirklich jemanden interessiert ;) :( Das Offline-Programmiersystem (Famos, bei mir) schreibt die EK-Funktion direkt raus. Das hat mit Base-Nummern gar nichts zu tun, in der Routine, die die Bewegungsbahn darstellt, taucht irgendwann etwas auf wie

    Code
    $BASE=EK(MACHINE_DEF[2].ROOT, MACHINE_DEF[2].MECH_TYPE,AP_S_01_00M:{X 0.00, Y 0.00, Z 0.00, A 0.00, B 0.00, C 0.00})

    , wobei AP_S_01_00M ein Frame ist, der selbst auch vom Famos festgelegt wird.
    Soweit. so gut. Jetzt muss ich aber auf die solcherart festgelegten Arbeitspunkte noch etwas draufrechnen, auf der externen Achse steht nämlich eine Bearbeitungsmaschine, deren Werkzeug sich abnutzt. Also veranlasse ich Famos NACH obigem $BASE=EK(...), in eine Routine zu springen, in welcher ich das noch mal mache, diesmal allerdings mit dynamisch angepassten Werten.
    Natürlich liegt zu dieser Zeit alles fest, und ich kann die Parameter, die ich brauche, vorher speichern. Aber: es gibt keinen zwingenden Zusammenhang zwischen dem, was Famos als Grundlage für seine Bahnerzeugung annimmt und dem, was in meiner Routine als Parameter übergeben wird. Man kann das Programm schließlich auch nachträglich editieren oder aber Parameter vergessen, oder auch von einem Punkt zum nächsten springen, bei dem vielleicht schon wieder ein anderer Arbeitspunkt definiert wurde.
    Also wollte ich - nur zur Sicherheit und hoffentlich ohne praktische Relevanz - in meiner Routine abfragen, ob Famos vorher etwas Ähnliches herausgeschrieben hat. Wenn ja, ist alles okay, wenn nein, hat sich jemand verprogrammiert. Ich hab's lieber, wenn die Software es vor der Hardware merkt, und überprüfe gerne alles, was ich überprüfen kann. (Einer unserer SPS-Programmierer trägt mir seit Jahren nach, dass der Robbi in einer Anlage mal stehenblieb mit der Meldung: "SPS lügt bezgl. Bauteilzustand". :lol: )


    Grubba: Wenn, dann Expert-Tech und KRL-Assistent. Die internen Base-Nummern werden aus naheliegenden Gründen (siehe oben) nur bei eher simplen Aufgabenstellungen verwendet.


    Danke nochmal allerseits, und Grüße,
    Michael

    Aha, kannst Du Famos nicht dazu überreden einen Code mit Inlineformularen zu generieren ? Dann müßte nur noch der "Ändern"-Softkey gesperrt werden um eine
    Base-Tooländerung zu verhindern.
    TouchUp bleibt erhalten.
    Dadurch werden auch Probleme mit Satzanwahl verhindern. Die Verschleisskompensation wäre auch sehr einfach:


    BASE_CORR=$nullframe
    BASE_CORR.Z= Verschleiss
    BASE_CORR_ON=TRUE


    ; jede Menge Punkte, TouchUp wird auch bei Base_Corr auf das Originalbauteil zurück gerechnet.


    Ich glaube das dies für den Bediener die einfachste und sicherste Methode wäre.

    Hm, wäre auch eine Möglichket (wenn Famos das realisieren könnte, was es nicht tut). Allerdings werden die Dateien dann schnell sehr groß, und bei ein paar Tausend Punkten geht der Überblick verloren und der Kuka streicht die Segel. Dann möchte Famos das Ganze ja auch noch zurücklesen können im Bedarfsfall und ich auch ... der entscheidende Vorteil wäre tatsächlich bei Satzanwahl/Satzvorlauf.
    Nee, das passt schon so am Besten wie es ist, bis auf dieses kleine Detail. Ich wüsste auch im Moment nicht, wie ich ca. 200 Bases (bzw. feststehende Tools) in Inlineformularen verwalten sollte.
    Die BASE_CORR-Sache ist allerdings was, was bislang völlig an mir vorbeigegangen ist... wieder was dazugelernt. Wobei sich hier die Katze in den Schwanz beisst:
    BASE_CORR.Z= Verschleiss[von welcher Maschine denn nur?]
    TouchUp bezieht sich ja sowieso immer auf die aktuelle Koordinatensystemkombination, von daher geht das immer.


    Danke jedenfalls für die Anregungen, ich muss jetzt sowieso erstmal bei einem anderen Projekt wüten und meine interne Programmiersoftware wieder auf ABB Rapid umstellen. :(


    Grüße,
    Michael

    $BASE_KIN[]


    Die Variable enthält den Namen und eine Liste der in der Transformation enthaltenen
    Zusatzachsen. Name und enthaltene Zusatzachsen sind in den Maschinendaten
    definiert, z. B. $ET1_NAME und $ET1_AX.

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