What is the "JUMP" "GOTO" Programming instruction in Staubli

Hello Joao,

You can do loops with these instructions:

1. For (if the step is 1)
2. For (if the step is different to 1)
3. While
4. Do-until

for i=0 to 9
    // Code to repeat
endFor

for i=9 to 0 step -1
    // Code to repeat
endFor

while nVal>0
    // Code to repeat
endWhile

do
    // Code to repeat
until nVal<=0

Not conversant with Staubli, however I believe the language is based on VAL and Kawasaki also is too.

In addition to what Psyril has already written.

Staubli may also use 'labels' (which is a word followed by colon or just a number) and 'goto' as the link to the label.

Where a label could be:

10

or

retry:

and you would then just require:

GOTO 10

GOTO retry

As I said, not conversant with Staubli, but worth a try...…

Staubli is a "programmer's robot" and the language is much more sophisticated than most robot programming languages. It would help if you had a C++ programmer's mindset.

It's been a while since I used the Staubli VAL3 language. I checked my old VAL3 Language Reference to confirm. I don't see that the VAL3 language supports simplistic JMP-LBL or GOTO language constructs. The language was developed to perform highly complex actions beyond simple technician-level programming. In large, complex programs JMP-LBL & GOTO commands will make the code unsupportable because it will be difficult to follow the logic and program flow for diagnostics.

In addition to the constructs provided by Psyril, you also have available the CALL-RETURN constructs. For me, that is what takes the place of JMP-LBL & GOTO constructs. My programs would have many subroutines.

Usually I program Staubli robots creating a state machine inside a switch-case statement, this way I can structure the program more like a FANUC robot.

With you Comau as an example, something like unloading 2 parts, with the robot trying to pick each one again, would look like this:

nStep = 0
while (true)
  switch (nStep)
    case 0
      if (diUnloadRequest == true)
        nStep = 10
      endIf
    break
    case 10
      //Unload part 1
      movej(pMesa, tool[1], mMesa)
      movej(appro(pMesa[1], trMesaApprox), tool[1], mMesaApprox)
      movel(pMesaPega[1], tool[1], mMesaPega)
      waitEndMove()
      delay(0.2)
      ...
      nStep := 11
    break
    case 11
      //Check part unloaded
      if (diPartPresent[1] == true)
        //Error: part not unloaded
        nStep = 12
      else
        //Ok, unload next part
        nStep = 20
      endIf
    break
    case 12
      //Buzzer on, wait for alarm reset
      doBuzzer = true
      wait(diFaultReset == true)
      doBuzzer = false
      nStep = 10 //Try picking the part again
    case 20
      //Unload part 2
      ...
    break
    case 21
      //Check part unloaded
      if (diPartPresent[2] == true)
        //Error: part not unloaded
        nStep = 22
      else
        //Ok, unload completed
        nStep = 0
      endIf
    break
    case 22
      ...
    break
endWhile

Of course, as TygerDawg pointed out, VAL3 is much more powerful compared to the languages used by the other robots.

I would try to take advantage of the many features it offers.