Shibaura SCOL Programming: Structure, Labels and Multitasking

What each section is for:

• GLOBAL ... END — the global variable area. Anything declared here is readable and writable from anywhere in the file. To fix a variable's type you must give it an initial value; arrays are the exception, since DIM sets their type and element count separately.
• PROGRAM <name> ... END — the program section, and the actual code. Omit the END and you get a compile error. A file can hold many program sections; PROGRAM MAIN is the conventional entry point, and subprograms may take arguments, as in PROGRAM SUB1(N1, N2, N3).
• DATA ... END — the data section, holding taught positions and coordinate data as POINT, JOINT and TRANS declarations.

The rules that actually bite:

• A GOTO can only branch within the same program section. There is no cross-program jump — call a subprogram instead.
• A GOTO whose label does not exist in that program is a compile error.
• Two statements sharing one label name in the same program is also an error — the controller cannot pick a destination.
• The colon belongs to the definition only. LOOP: defines, GOTO LOOP jumps.

RCYCLE constraints:

• It may appear only once in the main program.
• Your flow must guarantee that the RCYCLE: line is actually reached at least once.
• It cannot be used in a multitask program — combining RCYCLE with TASK raises an error.

Why each part is there:

• ACCUR = COARSE up front, with WITH ACCUR = FINE only on the moves that must land precisely. The controller default is FINE, which forces an exact in-position check before the next statement — every waypoint becomes a dead stop and no path blending is possible.
• RESET DOUT and OPEN1 put the cell in a known state instead of inheriting whatever the last abort left behind.
• WAIT MOTION >= 100 before gripping. MOTION reports progress of the current move as a percentage, so this is how you confirm the arm has arrived rather than guessing with a delay.
• DELAY 0.3 after CLOSE1/OPEN1 because the gripper is pneumatic — the output changes state well before the jaws do. If you have hand-feedback inputs, WAIT DIN(...) on them is strictly better than a fixed delay.
• IF MODE == CYCLE THEN GOTO CYCLEEND lets the same program serve single-cycle dry runs and continuous production. Without it, a cycle-mode start still runs forever.
• The reject branch rejoins at CYCLETOP:, not at RCYCLE: — a scrapped part must not re-run initialisation.
• The label is CYCLETOP:, not CYCLE:, because CYCLE is a reserved word — it is the system constant compared against MODE. Appendix B of the manual lists every reserved word, and it is worth checking your label and variable names against it. TID is another easy one to trip over.

The four primitives:

• MAXTASK — declares how many tasks may run at once. It is valid only in the GLOBAL section, the maximum is 4, and the correct value is the number of TASK calls plus one for the main task. The controller work area is divided equally between tasks, so an inflated MAXTASK shrinks the space each task gets and can make a large program unloadable.
• TASK("<name>") — starts the named program section as a task and returns its task ID. A return of 0 means it failed to start, which is worth testing rather than assuming.
• SWITCH — yields to another task. SCOL will not preempt a tight loop for you, so this is mandatory, not decorative.
• KILL(<expression>) — terminates the task with that ID. Killing task ID 1 or a nonexistent ID is a no-op rather than an error. A task restarted afterwards with TASK receives a new ID.

Read these before you write your second task:

• Motion belongs to the main task alone. MOVE and MOVES in a subtask are an error. A subtask can watch signals, count, and drive outputs — it cannot move the arm.
• ENABLE NOWAIT is shared by every task, not scoped to one. The manual suggests it for an I/O subtask, but switching it on there leaks into MAIN and makes MAIN's motion non-blocking, so MAIN races ahead of the arm. The symptoms are baffling: a gripper cycling mid-travel, or a homing routine reporting complete while the arm is still moving. Leave it at the default DISABLE NOWAIT unless you have set the per-task controller parameter.
• A subtask cannot drive an output while MAIN is moving. Its DOUT is deferred until MAIN's active motion finishes, while MAIN's own DOUT takes effect immediately. So never give a time-critical output to a subtask — let MAIN command it and let the subtask only re-assert or maintain it.
• WAIT on a plain variable never yields. WAIT DIN(1) yields properly, but WAIT FLAG == 1 spins, starves MAIN, and MAIN is then never scheduled to set FLAG — a deadlock. Synchronise tasks through I/O conditions, or poll a variable in a loop that calls SWITCH.
• ON <cond> DO <stmt> is not a background task. It is one-shot: monitoring stops once the action fires. It does not monitor during motion under DISABLE NOWAIT, and if a WAIT is in progress when it triggers, that WAIT is cancelled outright. Use it for a genuine one-time event, not to fake concurrency.