Beiträge von Prestorianer

    Was vielleicht ganz interessant ist, ist das sich die Bewegungsplanung etwas geändert hat.
    Beim KRC4 wird ein neuer Parameter "c_dis" eingeführt der das Überschleifverhalten im Punkt nicht als Prozent sondern in Millimetern angibt.


    Als ich das gehört hab, hab ich gedacht: WOW endlich kannste bei 30% T2 aufhören und das ding fährt dann bei 100% genau so.
    Pustekuchen.
    Der KRC4 verhällt sich wieder KRC2 bis 75% T2 relativ bahntreu.
    Beim Sprung auf 100% können, wenns eng wird, auch mit der neuen Steuerungen Kratz und Klopfgeräusche aus dem Bauteilinneren kommen. :applaus: Bravo KUKA, Bravo....

    Also ich hab von nem Kunden die Aufgabe bekommen während Automatik rückwärts bis nach Home zu fahren, sobald ein Eingang ansteht.


    Das braucht 3 Programme


    - Interruptdefinition für einen Eingang mit Aufruf eines Abbruchprogrammes;
    - der Aufruf des normalen Unterprogrammes
    def Hauptprogramm();
    GLOBAL INTERRUPT DECL 25 WHEN $IN[1]==TRUE DO Abbruch()
    Unterprogramm ()
    end



    - Im Unterprogramm den Interrupt einschalten
    - Vor jedem für die Rückwärtsfahrt relevanten Punkt über einen Trigger eine Variable mit dem namen des aktuellen Punktes beschreiben. Wichtig ist hierbei die Distancevariable.
    0 heist: triggern kurz nach start von dem Punkt
    1 heist: kurz vor erreichen des nächsten Punktes
    def Unterprogramm ()
    INTERRUPT ON 26

    TRIGGER WHEN DISTANCE=0 DELAY=0 DO Akt_Pos=#GHP5
    PTP GHP5 CONT Vel= 100 % PDAT Tool[1] Base[15]

    TRIGGER WHEN DISTANCE=1 DELAY=0 DO Akt_Pos=#GHP6
    LIN GHP6 Vel= 2 m/s CPDAT Tool[1] Base[15]
    end




    - Wenn der Eingang 1 ist wird der Interrupt ausgelöst und das Abbruch () - Programm gestartet.
    - sobald das abbruchprogramm läuft durch läuft es selbstständig eine switch in einer repeat die solagen läuft bis die Variable #ENDE heist.
    - Es können ohne Probleme auch Funktionsaufrufe, Ausgänge, Eingänge gesetzt/abgefragt werden bei jedem Pu
    - Wichtig ist das bei jedem Case ein bestimmter Punkt angefahren und nach erreichen die Variable AKT_POS neu beschrieben wird.


    Danach erfolgt durch den Interrupt ein aussprung in das Hauptprogramm.
    def abbruch ()
    REPEAT

    SWITCH AKT_POS

    Case #GHP1
    PTP GHP1 Vel= 100 % GLOBAL Tool[1] Base[1]
    irgendwas ( )
    Akt_Pos=#Home_Pos

    Case #GHP2
    PTP GHP2 Vel= 100 % GLOBAL Tool[1] Base[1]
    $OUT[1]=true
    AKT_POS=#GHP1

    Case #GHP3
    LIN GHP2 Vel= 1 m/s GLOBAL Tool[1] Base[1]
    Akt_Pos=#GHP2

    Case #Home_Pos
    PTP HOME Vel= 100 % DEFAULT
    Akt_Pos=#ENDE

    ENDSWITCH

    Until Akt_Pos==#ENDE
    end



    zu Guter letzt fehlen noch ein paar Einträge in der $Config.dat
    - Deklaration von AKT_POS (jeder name eines Punktes muss dort angegeben werden)
    - Einzige Einschränkung hierbei ist die maximale Zeilenlänge einer Zeile in der Config, liegt glaub ich bei 400 Zeichen
    - Alle Punkte mit denen Rückwärts gefahren werden soll, müssen global in der config definiert werden.
    also raus aus der dat vom unterprogramm und rein in die config verschieben


    def $config.dat
    ENUM POSITION HOME_POS,GHP0,GHP1,GHP2,GHP3,ENDE
    DECL POSITION AKT_POS


    DECL E6POS XGHP1={X 2659.09595,Y 866.297119,Z -826.614685,A -163.897598,B -3.92666292,C -9.76089096,S 22,T 27,E1 0.0,E2 0.0,E3 0.0,E4 0.0,E5 0.0,E6 0.0}
    DECL E6POS XGHP2={X 2886.66699,Y 383.833008,Z -773.285828,A -166.008499,B -0.164955705,C -1.38541496,S 22,T 27,E1 0.0,E2 0.0,E3 0.0,E4 0.0,E5 0.0,E6 0.0}
    DECL E6POS XGHP3={X 2904.43188,Y 363.410187,Z -564.47467,A -162.226303,B -0.160164803,C -1.38474798,S 22,T 27,E1 0.0,E2 0.0,E3 0.0,E4 0.0,E5 0.0,E6 0.0}
    DECL FDAT FGHP1={TOOL_NO 1,BASE_NO 2,IPO_FRAME #BASE,POINT2[] " "}
    DECL FDAT FGHP2={TOOL_NO 1,BASE_NO 2,IPO_FRAME #BASE,POINT2[] " "}
    DECL FDAT FGHP3={TOOL_NO 1,BASE_NO 15,IPO_FRAME #BASE,POINT2[] " "}
    end




    Der Vorteil der Beschreibung der Variable mit dem Namen des Punktes ist, das man später in der Variablenübersicht
    sofort sieht welchen Punkt der Robbi anfahren würde wenn ein Abbruch kommt



    Viel Spass damit :dadr:

    dein 1. Problem wird wohl ein Problem bleiben.


    Soweit mir bekannt ist geht das nicht.
    Der Roboter läuft nicht mit programmen oder Variablen von irgendeiner festplatte, sondern die programme müssen erst in einen eigenen "Speicher" geschrieben werden. das macht die BOF. Da kommste von außen nicht dran. da alles was dort drin steht durchläuft den debugger.
    sonst könntest du ja irgendwelche syntaxfehler während des programmablaufs ausführen, und was der robbi dann macht weis nur gott
    Deswegen siehst du auch im ExpertenModus im Navigator ganz oben den Roboter mit seinen unterverzechnissen und drunter die Laufwerke.


    Was ich dir empfehlen kann ist die Variablen per RS232 zu übertragen.

    Ja, ist lesbar.


    Was im Robcad passiert ist eigentlich irrelevant. Letztendlich wird ein sogenannter Download gemacht, bei dem ein Script die Informationen aus Robcad in ein KRC Programm übersetzt.
    Das kannste dann nehmen und sofort in den Roboter einspielen (das funzt zu 99%)


    Gruß Thomas

    Kontrollier doch mal die DSE/RDW-Leitung. Könnt ja sein das die nicht richtig aufgesteckt/gedreht ist.


    Ich hab auch schon ein paar mal erlebt das Justageverlust angezeigt wurde und als ich mit dem EMT zurück kam war alles weg.
    Sozusagen eine Selbstjustage :nocheck:

    Hierzu wär noch was anzumerken
    Es ist völlig egal ob einer der beiden Werte INT ist.


    Bei diesen 3 Möglichkeiten werden immer die Kommastellen abgeschnitten.
    DECL INT A
    7.0/4 = 1
    7/4=1
    7/4.0=1


    will mann trotzdem 1,75 als Ergebnis bekommen so muss mann
    7*0,25
    rechnen.


    Danach könnte man diesen REAL wert in einen Integer schreiben und man erhält die Rundung


    DECL INT A
    A=7*0,25 ; A = 2


    Bye

    Tach auch


    also Langtext anzeigen, geht, aber find grad kein beispiel dafür. Aber vielleicht hilft dir das Beispielprogramm weiter. Das müsste dann fehlerfall aufgerufen werden. z.B.


    WHILE (FEHLER==TRUE) OR ($IN[4]==FALSE)
    MSG_DEMO ()
    ENDWHILE



    BEISPIELPROGRAMM
    &ACCESS R
    &COMMENT Example on user messages
    DEF MSG_DEMO ( )


    ; To run program -> change first line "&ACCESS R"
    ; into "&ACCESS RVP" and select program again !!!


    DECL INT ANSWER
    DECL INT OFFSET
    DECL STATE_T STATE
    DECL MSG_T EMPTY_MSG


    EMPTY_MSG={MSG_T: VALID FALSE,RELEASE FALSE,TYP #NOTIFY,MODUL[] " ",KEY[] " ",PARAM_TYP #VALUE,PARAM[] " ",DLG_FORMAT[] " ",ANSWER 0}


    ;---------------------QUITTIERUNGSMELDUNG----------


    $MSG_T=EMPTY_MSG
    $MSG_T.MODUL[]=" "
    $MSG_T.KEY[]="DEMO: QUIT-MESSAGE + %1"
    $MSG_T.PARAM[]="PARAM"
    $MSG_T.PARAM_TYP=#VALUE
    $MSG_T.TYP=#QUIT


    $MSG_T.VALID=TRUE


    WHILE $MSG_T.VALID
    WAIT SEC 0.05
    ENDWHILE
    WAIT SEC 0.2


    ;------------------DIALOGANFRAGE----------------


    $MSG_T=EMPTY_MSG
    $MSG_T.MODUL[]=" "
    $MSG_T.KEY[]="DEMO: DIALOG + %1"
    $MSG_T.PARAM[]="PARAM"
    $MSG_T.RELEASE=FALSE
    $MSG_T.PARAM_TYP=#KEY
    $MSG_T.TYP=#DIALOG
    $MSG_T.DLG_FORMAT[]="A|B|C"


    $MSG_T.VALID=TRUE


    WHILE $MSG_T.VALID
    WAIT SEC 0.05
    ENDWHILE
    WAIT SEC 0.2
    ANSWER=$MSG_T.ANSWER


    ;------------------HINWEISMELDUNG------------------


    $MSG_T=EMPTY_MSG
    $MSG_T.MODUL[]=" "
    $MSG_T.KEY[]="DEMO: DIALOG ANSWER = %1"
    OFFSET=0
    SWRITE($MSG_T.PARAM[],STATE,OFFSET,"%d",ANSWER)
    $MSG_T.PARAM_TYP=#VALUE


    $MSG_T.VALID=TRUE


    WHILE $MSG_T.VALID
    WAIT SEC 0.05
    ENDWHILE
    WAIT SEC 0.2


    ;------------------- SIMULATION-----------------------


    $LOOP_CONT=TRUE
    WHILE $LOOP_CONT
    $LOOP_MSG[]="S|HALLO ich die SIMULATION eines Schleifenabbruchs!"
    ; S| erzeugt die Simuliere-Taste !!!!!
    ENDWHILE
    $LOOP_MSG[]=" "
    END

    Tach auch :zwink:


    Zu erst einmal solltest du sicher stellen das du dich im Koordinatensystem des Werkzeugtisches befindest. Das erreichst du wenn du den Nullpunkt relativ zum Roboter in BASE_DATA[1] einträgst. Normalerweise kann man das mit Hilfe des Roboters einmessen (3 oder 4-Punktmethode...)


    Beispiel:
    BASE_DATA[1]={X 2369.51294,Y -1700.56201,Z 1996.70398,A 90.0876083,B -0.0217150003,C -0.134186998}


    Wenn du jetzt dein (leicht geändertes :idea: ) Programm....
    $base=base_data[1] ;festst. Werkzeug
    $tool=tool_data[2] ;Werkstück am Roboterflansch
    $ipo_mode=#BASE ;<<<--- Änderung
    PTP Home
    PTP (X 800,Y 600,Z 1200, A 0, B 90, C 180)


    ...ausführst bewegt sich der Roboter innerhalb des angegebenen BASE[], erstmal egal mit welchem Tool. Wichtig ist in erster Linie die Drehung des BASE[], wenn du nicht unbedingt genaue Koordinaten innerhalb des Werkzeugtisches anfahren musst.



    Nun zum $ipo_mode
    #BASE heist du führst das Werkzeug am Roboter (bsp. Schweißzange) beim TCP-Verfahren (ext. Tool) durch das Koordinatensystem des Werkzeugtisches


    #TCP heist du führst das Bauteil/Werkstück mit hilfe eines Greifers in eine externe feststehende Schweißzange und willst innerhalb des Koordinatenssystems des Bauteils punkte anfahren. Ist gewöhnungsbedürftig aber nicht schwierig. Stell dir vor du fährst die ext. Zange und nicht den Roboter wenn du TCP(ext.Tool) verfährst. (Is blöd zubeschreiben, stimmt :kopfkratz:)


    Ich hoffe das war hilfreich, ansonsten weis ich auch nicht weiter.

    Hi,


    was meinst du mit Werkzeug teachen :nocheck: Nur Punkte können geteacht werden, oder irre ich mich da. :kopfkratz:


    Was du probieren kannst, ist das Offset für jedes Werkzeug zu ermitteln.
    findest du bei Inbetriebnahme-->Justage-->Offset lernen (zumindes in der deutschen Version).
    Dann schreib er sich zu jedem Werkzeug das passende Offset in die CAL datei


    bye

    Servus,


    warum macht ihr euch den Aufwand mit dem Datenschieben von PC zu Roboter.
    Das ganze hört sich für mich nach einer einfachen Suchaufgabe für den Roboter an.


    Daher mein Vorschlag:
    Am Robotergreifer einen Lasersensor anbringen. Danach ein Programm mit BASE teachen (das ist wichtig) was den Roboter von A nach B über eine Kante am Bauteil fährt. Dabei registriert der Robbi die Änderung des Lasers von 0 auf 1 und schreibt sich an der Stelle mit $act_pos die Koordinaten weg.
    Das ganze muss 2 mal gemacht, werden. Das erstemal mit einem Rererenzbauteil, damit ihr wisst wo ihr euch befindet. Danacht kann über das Programm das Offset von Referenzbauteil zu aktuellem Bauteil ermittelt werden. Wichtig ist das ihr beim teachen ein Base benutzt was ihr über die Offsetrechnung verschiebt. Dadurch fährt der Robbie wieder an die richtige Position.


    Mein Vorschlag kommt wahrscheinlich zu spät, aber er ist einfach und funktioniert ohne PC. Ich hab solche Suchfunktionen schon in 3 Projekten intetriert, ich weis also wo von ich rede.


    Bye