Control Authority

How Arc resolves conflicts when multiple writers target the same channels

When multiple writers target the same channel (two Arc programs, an Arc program and a Python script, or an Arc program and a schematic control), authority determines whose values take effect. Without it, writers would overwrite each other unpredictably.

Declaring Authority

The authority declaration sets the level a program writes at. The reference page lists every form it accepts.

Default Authority

Default authority for a task when not declared is 255

A task at 255 cannot be overridden, which suits a single writer but leaves no room to escalate or to hand control to an operator. Declare a lower value, such as 200, to keep both options open.

Changing Authority at Runtime

Declare a top-level authority to set the task default. Use control.set_authority inside stages to change it during execution:

import control
import time

authority 100

sequence main {
    stage monitor {
        sensor -> filter{} -> output
        sensor > THRESHOLD => escalate
    }

    stage escalate {
        control.set_authority{value=200}
        true -> press_vlv_cmd
        time.wait{duration=5s} => done
    }

    stage done {
        false -> press_vlv_cmd
    }
}

start_cmd => main

Authority changes apply before channel writes in the same execution cycle of a stage, so control.set_authority and channel writes can safely coexist.

How Multiple Writers Interact

The authority system follows three rules:

Higher authority wins. A writer at authority 200 takes precedence over one at 100. The lower-authority writer’s values are silently dropped for that channel.

Equal authority: first in wins. When two writers have the same authority, the one that acquired the channel first keeps control. The second writer’s values are dropped.

Auto-resume on release. When a higher-authority writer releases a channel (by stopping or lowering its authority), the next highest writer automatically regains effective control. No restart or re-acquisition is needed.

These rules apply uniformly across all writer types. Arc programs, Python scripts, and schematic controls all participate in the same authority system.

Emergency Escalation

A common pattern is starting at moderate authority and escalating when an emergency is detected:

import control

authority 100

sequence main {
    stage normal {
        sensor -> controller{} -> output
        emergency_condition => emergency
    }

    stage emergency {
        control.set_authority{value=255}
        false -> press_vlv_cmd
        true -> vent_vlv_cmd
    }
}

start_cmd => main

At authority 100, the program runs alongside other writers. When the emergency stage activates, it jumps to 255 and overrides everything, including other Arc programs, Python scripts, and schematic controls.

Releasing Control

Setting authority to 0 gives a program the lowest possible priority. Any other writer takes precedence:

import control

authority 200

sequence main {
    stage active {
        true -> press_vlv_cmd
        done_condition => yield
    }

    stage yield {
        control.set_authority{value=0}
        false -> press_vlv_cmd
    }
}

start_cmd => main

This is useful when two Arc programs coordinate over the same channels. A high-priority program lowers its authority when it finishes, allowing a lower-priority program to resume without restarting.

control.set_authority{value=0}