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 keyword sets a program’s authority level. Place it before any func, sequence, or flow declarations:

authority 200

sequence main {
    stage pressurize {
        1 -> press_vlv_cmd,
        ox_pt_1 > 500 => next
    }
    stage complete {
        0 -> press_vlv_cmd
    }
}

start_cmd => main

Authority values range from 0 to 255. Higher values take precedence over lower ones.

For different channels, use the grouped form:

authority (200 press_vlv_cmd 100 vent_vlv_cmd 150)

This sets a default of 200, then overrides press_vlv_cmd to 100 and vent_vlv_cmd to 150.

Default Authority

When omitted, authority defaults to 255 — the maximum. This means a program without an explicit declaration has the highest possible priority and cannot be overridden by any other writer.

Starting at 255 works for simple cases with a single writer, but prevents escalation and manual override in multi-writer setups. Choosing a lower value like 200 leaves room for emergency overrides and operator intervention.

Changing Authority at Runtime

Use set_authority inside stages to change authority during execution:

authority 100

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

    stage escalate {
        set_authority{value=200},
        1 -> press_vlv_cmd,
        wait{duration=5s} => done
    }

    stage done {
        0 -> press_vlv_cmd
    }
}

start_cmd => main

Authority changes are flushed before channel writes in the same execution cycle, so set_authority and channel writes can safely coexist in the same stage.

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:

authority 100

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

    stage emergency {
        set_authority{value=255},
        0 -> press_vlv_cmd,
        1 -> 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.

If you start at 255, you have no room to escalate. Starting lower preserves this capability.

Releasing Control

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

authority 200

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

    stage yield {
        set_authority{value=0},
        0 -> 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.