Work Object Orientation for Vision

Are they set up independently or as a MultiMove system ?

[Edit] I assume that each robot is set up with the track in the same task, and as "Baseframe move by", but is the two robots set up on an independent controller or as a part of a multimove system [\Edit]

So, if I get this right....

You've established a "Zero" position for each robot.

You know the relationship / distance between that Zero and the Camera(s) Zero ?
The Camera system will feed you the distance / offset from the Camera-Zero to the part ?

I'd probably look into PoseVect and PoseMult - assuming I'm understanding the setup correctly.

All the robots think they are in the same location (base frames match). This means that they should all have the same workobject, so that a single vision result can be given to all robots in the cell. Wherever the shared location of the workobject is, put that into the U-Frame

put the vision offsets into the o-frame. Here's the basic structure, simplified slightly.

VAR pos VisionTranslationPoints:=[0,0,0];

VAR num VisionXRotation:=0;

VAR num VisionYRotation:=0;

VAR num VisionZRotation:=0;

VAR Wobj WobjExample;

VisionTranslationPoints.x:=giVisionX;

VisionTranslationPoints.y:=giVisionY;

VisionTranslationPoints.z:=giVisionZ;

VisionXRotation:=giRotX;

VisionYRotation:=giRotY;

VisionZRotation:=giRotZ;

WobjExample.oframe.trans:=VisionTranslationPoints;

WobjExample.oframe.rot:=OrientZYX(VisionXRotation,VisionYRotation,VisionZRotation);

Out of curiosity, which vision vendor are you using?

Okay, ISRA systems work in WorkObject coordinates, rather than Tool. It's been quite a few years, but I did a lot of ISRA rack-picking with IRC5s way back when.

(Disclaimer: I'm talking about ISRA Mono3D here, their product line may have changed since)

The trick is that, during system configuration, you have to give the ISRA system the actual robot position, with (IIRC) the WorkObject you're going to be using, and Tool 0 active. Then, the ISRA will give you an offset to apply to the WorkObject. You apply that offset to the WorkObject, and run from there. ISRA has (or used to) a RAPID module they would give you that would handle all this -- you pass their function the active WorkObject, the ISRA function modifies the OFrame portion of the WorkObject, and then you run your motions.

SkyeFire,

I've worked with ISRA as recently as this year, and your statements are still accurate.

Quote from ClaudiuA

Yeaaaah, not in this case. I got a pat on the back from ISRA mostly.

Hm! That's... odd. Well, they used to give it to everyone using Mono3D with ABBs, so:

%%%
  VERSION:1
  LANGUAGE:ENGLISH
%%%

MODULE ISRA_Vision(SYSMODULE)
  FUNC bool DoVision(
    intnum Type,
    INOUT wobjdata ResultWobj)

    ! Local variables
    VAR bool Flag;
    VAR pose Result;
    VAR num ResultX;
    VAR num ResultY;
    VAR num ResultZ;
    VAR num ResultRx;
    VAR num ResultRy;
    VAR num ResultRz;
    var num old_x;
    var num old_y;
    var num old_z;
    ! Set Automatic:=2 for regular operation
    ! Set Automatic:=3 for testing/vision simulation
    VAR num Automatic:=2;
    VAR pos Eulers;

    !
    ! Reset Errors
    SetGO goISRA_AllOuts,0;
    IF giISRA_Error<>0 THEN
      SetDO doISRA_Reset_E,1;
      WaitUntil giISRA_Error=0\MaxTime:=5\TimeFlag:=Flag;
      SetDO doISRA_Reset_E,0;
      IF giISRA_Error<>0 THEN
        TPWrite "Vision: unable to reset error, Error="\Num:=giISRA_Error;
        RETURN FALSE;
      ENDIF
    ENDIF
    !
    ! Set operating mode, if not AUTOMATIC
    IF giISRA_ComMirr<>Automatic THEN
      WaitUntil diISRA_Ready=1\MaxTime:=5\TimeFlag:=Flag;
      IF diISRA_Ready<>1 THEN
        TPWrite "Vision: not ready";
        RETURN FALSE;
      ENDIF
      SetGO goISRA_Command,Automatic;
      WaitUntil giISRA_ComMirr=2\MaxTime:=5\TimeFlag:=Flag;
      SetGO goISRA_Command,0;
      IF giISRA_ComMirr<>2 THEN
        TPWrite "Vision: unable to set Automatic";
        RETURN FALSE;
      ENDIF
    ENDIF
    !
    ! Set style ID
    WaitUntil diISRA_Ready=1\MaxTime:=5\TimeFlag:=Flag;
    IF diISRA_Ready<>1 THEN
      TPWrite "Vision: not ready";
      RETURN FALSE;
    ENDIF
    SetGO goISRA_ID,Type;
    SetDO doISRA_ID_valid,1;
    WaitUntil diISRA_ID_OK=1 OR giISRA_Error<>0\MaxTime:=5\TimeFlag:=Flag;
    SetDO doISRA_ID_valid,0;
    IF diISRA_ID_OK<>1 OR giISRA_Error<>0 THEN
      TPWrite "Vision: error setting type id, Error="\Num:=giISRA_Error;
      RETURN FALSE;
    ENDIF
    !
    ! Start measurement
    SetDO doISRA_Start_M,1;
    WaitUntil diISRA_Meas_ip = 1 OR giISRA_Error <> 0\MaxTime:=5\TimeFlag:=Flag;
    SetDO doISRA_Start_M,0;
    IF diISRA_Meas_ip <> 1 THEN
      TPWrite "Vision: error starting measurement, Error="\Num:=giISRA_Error;
      RETURN FALSE;
    ENDIF
    WaitUntil diISRA_Data_ip=0 OR giISRA_Error<>0\MaxTime:=15\TimeFlag:=Flag;
    IF diISRA_Data_ip<>0 THEN
      TPWrite "Vision: error measurement timeout, Error="\Num:=giISRA_Error;
      RETURN FALSE;
    ENDIF
    IF giISRA_Error<>0 THEN
      TPWrite "Vision: measurement error, Error="\Num:=giISRA_Error;
      RETURN FALSE;
    ENDIF
    !
    ! Convert result words to num
    ResultX:=giISRA_Offs_X/10;
    IF giISRA_Offs_X>32767 THEN
      ResultX:=-1*(65536-giISRA_Offs_X)/10;
    ENDIF
    ResultY:=giISRA_Offs_Y/10;
    IF giISRA_Offs_Y>32767 THEN
      ResultY:=-1*(65536-giISRA_Offs_Y)/10;
    ENDIF
    ResultZ:=giISRA_Offs_Z/10;
    IF giISRA_Offs_Z>32767 THEN
      ResultZ:=-1*(65536-giISRA_Offs_Z)/10;
    ENDIF
    ResultRx:=giISRA_Offs_Rx/1000;
    IF giISRA_Offs_Rx>32767 THEN
      ResultRx:=-1*(65536-giISRA_Offs_Rx)/1000;
    ENDIF
    ResultRy:=giISRA_Offs_Ry/1000;
    IF giISRA_Offs_Ry>32767 THEN
      ResultRy:=-1*(65536-giISRA_Offs_Ry)/1000;
    ENDIF
    ResultRz:=giISRA_Offs_Rz/1000;
    IF giISRA_Offs_Rz>32767 THEN
      ResultRz:=-1*(65536-giISRA_Offs_Rz)/1000;
    ENDIF
    
    ! Convert Euler to Quaterion
    Result.trans:=[ResultX,ResultY,ResultZ];
    Result.rot:=OrientZYX(ResultRz,ResultRy,ResultRx);
    TPWrite "Vision: OK, XYZ=  "\Pos:=Result.trans;
    Eulers.x:=ResultRx;
    Eulers.y:=ResultRy;
    Eulers.z:=ResultRz;
    TPWrite "Vision: OK, Eulers="\Pos:=Eulers;
    TPWrite "Vision: OK, rots=  "\Orient:=Result.rot;

    ! Shift ResultWob by vision result
    ResultWobj.oframe:=PoseMult(ResultWobj.oframe,Result);

    RETURN TRUE;
  
  ENDFUNC
  
ENDMODULE

Now, while it's production code that ran well for millions of cycles, it's perhaps not 100% polished. And it does include some inherent assumptions -- for example, that the ISRA will be sending signed 16bit integers (pre-multiplied by 10 for the mm values, and by 1000 for the degrees), and the RAPID Group Inputs are unsigned integers, hence the extra math if the incoming value is >32767 --- basically, if the sign bit is set.

But basically, you pass it a WorkObject and the ISRA style/recipe/type number, it handles all the communications, moddifies the WorkObject, and passes it back, along with a True for success, and a False for an error.

It should be bus-agnostic (this system was using DeviceNet), as long as you build your I/O in EIO.CFG the same way.

Of course, it's been enough years, modern ISRA systems may have different I/O maps now, so your mileage may vary.

¿No hacer una suma de vectores el resultado de la visión más el objeto de trabajo?

CAPMES? Well, I can't say I know anything about that one. Although, given the way ISRA normally does things, I'd be surprised if the robot interface was extremely different from Mono3D.

Quote from ClaudiuA

Except that we're using CAPMES in this case.

hello ClaudiuA,

I am very curious about CAPMES, but I can’t find some useful information about the system. Can you shared some information such as picture or document? My E-mail address is jjhhhz@126.com. Looking forward to your reply.