Beiträge von Micky

Hallo Sebastian,

Du hast recht, Konstanten können nicht beschrieben werden.

Aber mit der Instruktion "Test_Move2Pos" wird nicht der Wert der geteachten robtarget geändert, sondern es wird nur deren Inhalt (Positionswert) zum Anfahren der Position verwendet. Aus diesem Grund ist es überhaupt erst möglich die Funktionen "Offs" und "RelTool" direkt in dem Aufruf von "MoveL" zu verwenden.

Mfg
Micky

Hallo,

als Persistent müssen nur Tool und Wobj übergeben.

Robtargets benötigen keinen Festlegung des Datentyps, da ansonsten nur Robtargets, die als PERSISTENT deklariert sind, verwendet werden können, d.h. Du kannst weder das Ergebnis einer Funktion noch eine Konstante übergeben.

WObj ist normalerweise ein optionaler Parameter und muss in Deinem Fall immer übergeben werden.
Optionale Parameter könnnen durch die Verwendung eines "?" anstelle von ":=" weitergeben werden, falls der Parameter verwendet wird.

Siehe nachfolgendes Beispiel:

PROC Test_Move2Pos(robtarget pTarget,PERS tooldata tTool\PERS wobjdata wWobj,...)
 MoveJ Offs(pTarget,offset{1},offset{2},offset{3}),TravelSpeed,z5,tTool,\WObj?wWobj;

Da deine Zone kein optionaler Parameter ist, macht die Abfrage "IF Present(Zone)" keinen Sinn, da dieser Parameter immer vorhanden ist.

Mfg
Micky

Hi,
Du solltest einen digitalen Ausgang in den Systemparameter anlegen, der vorzugsweise über eine E/A-Einheit elektrisch mit Deinem Ventil verbunden ist.

Mfg
Micky

Hi,

hier ist ein Beispiel wir man die Palettierposition bezogen auf ein Werkobjekt, das zuvor für die Palette eingerichtet wurde berechnen kann.

Beim Teachen und beim Palettenwechsel muss der Zähler "nPalette_PartCounter" auf 0 gesetzt werden bevor die Berechnungsroutine ausgeführt wird.

!  The robot place the part in a palletizing pattern into the station.
  !
  !  The palletizing is done in three dimensions, which means the part
  !  could be place in several layers. A layer could have several columns and rows.
  !
  !  The distance between the the columns (x-axis), rows (y-axis) and the layers (z-axis)
  !  could be defined with the following persistent:
  !       -nPalette_Xoffs,  -nPalette_Yoffs,  -nPalette_Zoffs
  !
  !  The number of rows, columns and layers will bes set by the following persistent:
  !       -nPalette_Xnum,  -nPalette_Ynum,  -nPalette_Znum
  !
  !  The direction of the palletizing could be defined in X-Y-Z or in Y-X-Zz direction
  !  via the boolean persistent bPalette_DirXYZ:
  !   - TRUE:  X-Y-Z
  !   - FALSE: Y-X-Z
  !
  !  The position of the robot is calculated depended on the part counter nPalette_PartCounter
  !  and the specified offsets for each axes.
  !
  !  The workobject wPalette and its direction has to be defined for the station, because the
  !  calculated part position will be used as object frame.





  !**********************************************************
  !*                   num declarations
  !**********************************************************
  !Number of parts in X directions
  LOCAL PERS num nPalette_Xnum:=5;
  !Number of parts in Y directions
  LOCAL PERS num nPalette_Ynum:=4;
  !Number of parts in Z directions
  LOCAL PERS num nPalette_Znum:=2;
  !Distance between the parts in X directions
  LOCAL PERS num nPalette_Xoffs:=200;
  !Distance between the parts in Y directions
  LOCAL PERS num nPalette_Yoffs:=200;
  !Distance between the parts in Z directions
  LOCAL PERS num nPalette_Zoffs:=200;
  !Number of palletized parts
  LOCAL PERS num nPalette_PartCounter:=0;
  !Maximum number of parts on the pallet
  LOCAL PERS num nMaxPartOnPallet:=0;
  !    
  !**********************************************************
  !*                 workobject declaration
  !**********************************************************
  TASK PERS wobjdata wPalette:=[FALSE,TRUE,"",[[0,0,0],[1,0,0,0]],[[0,0,0],[1,0,0,0]]];




  !**********************************************************
  !*  Procedure CalcPalPosition
  !*
  !*  Description:
  !*
  !*  Calculates the displacement on the work object to
  !*  place the part on the pallet
  !**********************************************************
   PROC CalcPalPosition()
    VAR num nMaxPartOnLayer;
    VAR num nXcount;
    VAR num nYcount;
    VAR num nZcount;
    VAR num nLayerCount;
    !
    !Calculate the number of parts per layer
    nMaxPartOnLayer:= nPalette_Xnum * nPalette_Ynum;
    !
    !Caluclate the maximum number of parts on the pallet
    nMaxPartOnPallet:= nMaxPartOnLayer*nPalette_Znum;
    !
    !Calculate the layer number beginning with 0
    nZcount:= nPalette_PartCounter DIV nMaxPartOnLayer;
    !
    !Calculate position on layer
    nLayerCount:=nPalette_PartCounter MOD nMaxPartOnLayer;
    !
    IF bPalette_DirXYZ THEN
      !
      !Calculate the number of rows and columns in xyz direction
      nXcount:=nLayerCount MOD nPalette_Xnum;
      nYcount:=nLayerCount DIV nPalette_Xnum;
      !
    ELSE
      !
      !Calculate the number of rows and columns in yxz direction
      nXcount:=nLayerCount DIV nPalette_Ynum;
      nYcount:=nLayerCount MOD nPalette_Ynum;
      !
    ENDIF
    !
    !calculate the oframe of the work object
    wPalette.oframe:=[[0,0,0],[1,0,0,0]];
    wPalette.oframe.trans.X:=wPalette.oframe.trans.X + nXcount*nPalette_Xoffs;
    wPalette.oframe.trans.Y:=wPalette.oframe.trans.Y + nYcount*nPalette_Yoffs;
    wPalette.oframe.trans.Z:=wPalette.oframe.trans.Z + nZcount*nPalette_Zoffs;
    !
  ENDPROC

Mfg
Micky

Hallo,
in der neuen Version von RWMT 6.08 befinden sich 14 neue Stationssymbole, unter anderem auch 3 Paletten icons.
Alle 14 Symbole sind in den Release Notes abgebildet.

Mfg
Micky

Hallo,

öffne ein zweites RobotStudio und verbinde Dich mit der virtuellen Steuerung die im ersten RobotStudio ausgeführt wird.
Dann hast Du Zugriff auf die Benutzersteuerung.

mfg
Micky

Hallo,

wie wäre es mit folgendendem Lösungsansatz:

- Alle Parameter für einen Datensatz werden in einem Record gespeichert
- Der Datensatz (Record) wird mit WriteAnyBin in eine Datei im Homeverzeichnis geschrieben (jeder Datensatz ist als separate Datei gespeichert)
- Der Dateiname muss eindeutig dem Datensatz zuzuordnen sein (z.B. durch Nutzung einer Programmnummer)
- Die erforderlichen Daten werden mit ReadAnyBin in die Recordvariable ausgelesen.

Mfg
Micky

Hallo,
wenn Du die Daten hinterher auch wieder Lesen können willst, solltest Du eine Textdatei und keine Binärdatei schreiben.

Zum Schreiben solltest Du an die Datei nur Strings übergeben, die Du bei der Übergabe an die Routine mit der Funktion "ValToStr" umwandeln kannst.

Das Problem hierbei ist lediglich die max. Stringlänge von 80 Zeichen, da ein Robtarget oder andere records mehr als 80 Zeichen lang sind.

D.h. in das Logfile sollten nur ausgewählte wichtige Daten geschrieben werden, da zum Einen das Schreiben die Abarbeitungszeit beinflusst und zum Anderen die Speicherkarte irgendwann voll ist.

Deswegen solltest Du auch unbedingt den verbleibenden Speicher vor dem Schreiben prüfen.

Mfg
Micky

Hallo,
leider ist es ist nicht möglich die einzelnenen Elemente eines Record über einen String zusammen zu bauen.

Du solltest für die Berechnung eine Hilfsfunktion verwenden, die wie folgt aussehen könnte:

FUNC jointtarget OffsJointT(jointtarget joint, num AxisNo, num Offset)
VAR jointtarget jtNew;


jtNew := joint;


!* Calculate new position
TEST AxisNo


CASE 1:
    jtNew.robax.rax_1 := joint.robax.rax_1 + Offset;
CASE 2:
    jtNew.robax.rax_2 := joint.robax.rax_2 + Offset;
CASE 3:
    jtNew.robax.rax_3 := joint.robax.rax_3 + Offset;
CASE 4:
    jtNew.robax.rax_4 := joint.robax.rax_4 + Offset;
CASE 5:
    jtNew.robax.rax_5 := joint.robax.rax_5 + Offset;
CASE 6:
    jtNew.robax.rax_6 := joint.robax.rax_6 + Offset;
CASE 7:
    jtNew.extax.eax_a := joint.extax.eax_a + Offset;
ENDTEST


RETURN jtNew;


ENDFUNC 


PROC MyTest()
  VAR jointtarget jtStart;
  VAR jointtarget jtCurrent;

  jtStart:=CJointT();

  FOR i FROM 1 TO 6 DO 
     jtCurrent:=OffsJointT(jtStart,i,10);
     MoveAbsJ jtCurrent,v100,z0,tool0;
  ENDFOR 

ENDPROC

Mfg
Micky

Hallo,

anbei das funktionierende Beispiel mit AliasIO:

PROC GripperOp(SIG_ACTION myAction,num action)
    VAR signaldo doForward;
    VAR signaldo doBackward;


    AliasIO myAction.doForwards,doForward;
    AliasIO myAction.doBackwards,doBackward;


    TEST action
    CASE forwards:
      SetDO doForward,1;
      SetDO doBackward,0;
    CASE backwards:
      SetDO doBackward,1;
      SetDO doForward,0;
    DEFAULT:
    ENDTEST
  ENDPROC

Mfg
Micky

Hallo,

GetSysData wird verwendet um das aktuelle Tool, Werkobjekt oder die Lastdaten auszulesen.

Zum Verbinden von Signalen kann die Instruktion 'AliasIO' oder alternativ auch die Instruktion 'GetDataVal' verwendet werden.

mfg
Micky

Hallo,
Du solltest evtl. die Option "885-1 SoftMove" verwenden, den die erlaubt es den Roboter kartesisch weichzuschalten.
Nähere Infos findest du im Handbuch.
Mfg
Micky

Hi,
ich glaube die folgende Funktion "RecalcRobT" hilft dir weiter:

Beispiel:  p20:=ReCalRobT(p10,tool1,tool1,wobj1,wobj2)


FUNC robtarget ReCalcRobT(
    robtarget point,
    PERS tooldata told,
    PERS tooldata tnew,
    PERS wobjdata wold,
    PERS wobjdata wnew)


    VAR pose ppnt:=[[0,0,0],[1,0,0,0]];
    VAR pose ppntnew:=[[0,0,0],[1,0,0,0]];
    VAR pose pb:=[[0,0,0],[1,0,0,0]];
    VAR pose pa:=[[0,0,0],[1,0,0,0]];


    ppnt:=[point.trans,point.rot];
    pa:=PoseMult(PoseInv(PoseMult(wnew.uframe,wnew.oframe)),PoseMult(wold.uframe,wold.oframe));
    pb:=PoseMult(ppnt,PoseMult(PoseInv(told.tframe),tnew.tframe));
    ppntnew:=PoseMult(pa,pb);
    RETURN [ppntnew.trans,ppntnew.rot,point.robconf,point.extax];
ENDFUNC

Gruß
Micky

Hi,
Du kannst für die Berechnung die Funktion "Distance" verwenden.

VAR num nDistance;


nDistance:=Distance(pPunktA.trans,pPunktB.trans);

Mfg
Micky

Hallo,
meines Erachtes gibt es seit RobotWare 6.04 eine Fehlerbehandlung für die Kollision.
Die Fehlernummer lautet: ERR_COLL_STOP

Die Verwendung der Fehlerbehandlung muss in den Systemparametern (SYS) über "Controller/General Rapid/CollisionErrhandling" explizit eingeschaltet werden.

Wichtig ist das eine Fehlerbehandlung in die erforderliche Routine eingebaut wird.

Alternativ gibt es von ABB das Produkt "HomeposRunning", das für Deinen Anwendungsfall evtl. verwendet werden kann. Das Thema wurde hier im Forum bereits schon mehrfach behandelt. Vielleicht suchst Du mal danach.

Gruß
Micky

Hallo,
wenn eine Task semistatisch bzw. statisch angemeldet ist, läuft sie immer.
eine normale Task wird mit dem Roboterprogramm gestartet bzw. gestoppt.
Du könntest evtl. auch das Stop-bzw. QStop-Event verwenden, um die Daten rauszuschreiben
Mfg
Micky

Hallo,
wenn Du die Datenänderung der Pesistenten per SingleSafe-Interrupt überwachst kannst Du sogar eine Änderung bei gestoppten Programm erkennen.
Der Ablauf bei Deiner Datenzuweisung sieht wie folgt aus:
1. Interrupts ablöschen
2. Daten zuweisen
3. Überwachungsflag "bDataChanged" auf False setzen
4. Interrupts aktivieren.
In deinem Programm musst Du dann nur noch prüfen, ob das Überwachungsflag "bDataChanged" immer noch den Wert FALSE hat. Sollte es TRUE sein, haben sich die Daten geändert.
Hier ein Beispiel:

var intnum irDataChanged{2};
task pers bool bDataChanged:=TRUE;
task PERS num nData1:=8;
task PERS num nData2:=4;


PROC main()
  !Datenzuweisung programmgesteuert
  DisableMonitoring;
  nData1:=2;
  nData2:=3;
  bDataChanged:=FALSE;
  EnableMonitoring;


ENDPROC 


TRAP T_DataChanged
  Tpwrite "Daten wurden geändert";
  bDataChanged:=TRUE;
  EnableMonitoring;
ENDTRAP


PROC EnableMonitoring()
  FOR i FROM 1 TO dim(irDataChanged,1) DO 
     idelete irDataChanged{i};
     CONNECT irDataChanged{i} WITH T_DataChanged;
  endfor    


  Ipers\SingleSafe,nData1,irDataChanged{1};
  Ipers\SingleSafe,nData2,irDataChanged{2};


ENDPROC


PROC DisableMonitoring()
  FOR i FROM 1 TO dim(irDataChanged,1) DO 
     idelete irDataChanged{i};
  endfor    
ENDPROC

Hallo,
du könnntest Dir in der Routine für die Zuweisung der Daten ein boolesches Flag setzen, dass später für die eine Änderung abgefragt wird.
Oder Du erzeugst für eine oder alle Persistenten einen Interrupt, der bei Änderung der Daten aufgerufen wird,
Z.B.

CONNECT intno1 WITH T_DatenGeandert;[/font][/size]
IPERS nLagerdurchmesserm,  intno1;[/font][/size]

Hallo,
bei den Systemeingängen kannst Du auch Ausgänge verwenden, leider funktioniert die Zuordnung nicht in RobotStudio.
Am besten Du erzeugst den Systemeingang in RobotStudio und verwendest einen beliebigen Eingang. Dann speicherst Du die EIO.CFG und öffnest sie mit einem TextEditor. Anschließend ersetzt du den Eingang mit dem Ausgang den Du verwenden möchtest. Nach dem Laden der EIO.CFG kann Du jetzt den Ausgang zum Schalten des Systeneingangs verwenden.
Gruß
Micky

Hallo,
hast Du eventuell in Deinem Programm die Achskonfiguration mit "ConfL\Off" bzw. "ConfJ\Off" abgeschaltet?
Wenn ja, könnte hier der Fehler liegen!
Der Roboter versucht dann die Position auf dem kürzesten Weg anzufahren und achtet dabei nicht auf die Konfiguration der Achsen, so dass die 6. Achse die Position auch um 180 Grad gedreht erreichen kann.
Du solltest die Achskonfiguration nur dann ausschalten, wenn es unbedingt erforderlich ist und sie bei nächster Gelegeheit sofort wieder einschalten. Denn ansonsten kann der Fehler immer wieder auftreten.
Mfg
Micky