Networked panels and peer-to-peer networks

Eastview General Hospital's fire alarm is not one panel but seven, one in each wing and the central plant, joined by a network so that an alarm anywhere shows everywhere it needs to and operates outputs in any part of the hospital. Ravi spreads the network riser diagram on the table. 'Control Panels and Circuits showed you how one panel works and touched on networks,' he says. 'Here we go into how the network itself works, how it fails, and how you find out which node is lying to you.' This lesson covers networked fire alarm systems: why they are used, how they are built, how they are supervised and how they are tested.

Why network panels

A single control unit has a limit on the number of loops, circuits and points it can handle, and running every circuit in a large building back to one room makes long, vulnerable cable runs. Large buildings and campuses therefore use several control units, called nodes, joined by a network. Each node handles the devices near it and shares its events and commands with the others. The network makes the system behave as one: an alarm detected by the north wing node appears on the main annunciator at the entrance, sounds signals in other wings according to the sequence of operation, and can release doors or shut down fans served by other nodes.

Networks also let a building be expanded in stages. When Eastview added its north wing, a new node joined the existing network instead of every new circuit running back to the main panel.

How the network is built

Fire alarm networks are proprietary to each manufacturer, but most share a few features:

• Peer-to-peer operation: each node holds the program for its own devices and the network rules it needs, and keeps working on its own if the network fails. There is no single master whose loss stops the system.
• A ring or Class X style topology: the network cable leaves each node and returns from the other direction, so a single open or short in the network cable doesn't split the system. The node reports the fault and the network keeps carrying messages the other way round.
• Wire, fiber or both: copper network circuits between nodes in the same building, and fiber between buildings or where long distances, lightning or electrical noise make copper a poor choice.
• Listed components: network cards, repeaters, fiber converters and annunciators listed for use with that control unit, so that the network's timing and supervision are proven.

What the network carries

Network messages carry events, such as alarms, supervisory signals, troubles and restorals, and commands, such as acknowledge, silence, reset, and the activation of outputs programmed to follow events on other nodes. Each node keeps a list of which network events it needs to act on and which it must display. The amount of traffic is usually small, but in a large alarm many messages arrive at once, and the network must deliver them in order and quickly enough that outputs on other nodes operate within the time the sequence of operation and the standard allow.

# How long does an event take to reach every node on a ring? (illustrative)
nodes = ["main", "east", "plant", "north", "west", "south", "emerg"]
hop_ms = 120            # typical time for a message to pass one node (illustrative)
def hops(a, b, broken=None):
    links = {frozenset((nodes[k], nodes[(k + 1) % len(nodes)])) for k in range(len(nodes))}
    if broken:
        links.discard(frozenset(broken))
    dist, todo = {a: 0}, [a]
    while todo:
        n = todo.pop(0)
        for l in links:
            if n in l:
                m = next(iter(l - {n}))
                if m not in dist:
                    dist[m] = dist[n] + 1; todo.append(m)
    return dist[b]
for target in ["main", "east", "plant", "west", "south", "emerg"]:
    print(f"north -> {target:6s} normal {hops('north', target) * hop_ms:4d} ms   plant-north open {hops('north', target, ('plant', 'north')) * hop_ms:4d} ms")

north -> main   normal  360 ms   plant-north open  480 ms
north -> east   normal  240 ms   plant-north open  600 ms
north -> plant  normal  120 ms   plant-north open  720 ms
north -> west   normal  120 ms   plant-north open  120 ms
north -> south  normal  240 ms   plant-north open  240 ms
north -> emerg  normal  360 ms   plant-north open  360 ms

With the ring intact, a message from the north wing reaches the farthest node in a few hundred milliseconds. With the link between the central plant and the north wing open, messages to the central plant, the east tower and the main panel go the long way round and take longer, but still arrive. The node reports the open link as a trouble so that it is fixed before a second fault splits the network.

Supervision and network troubles

Every node supervises its network connections. A network trouble may mean an open or shorted cable, a ground fault, a fiber that has lost light, a node that has stopped answering, or a node whose program doesn't match the network's records. The trouble message names the node and the connection, which is where the search starts. A node that loses contact with the rest of the network continues to operate its own devices and outputs, but events on other nodes no longer reach it, and its events no longer reach them, so the main annunciator and the monitoring center may stop hearing about part of the building.

For that reason, the connection to the monitoring center is usually made through a node that can see the whole network, and some designs place communicators on more than one node so that a network failure doesn't stop off-premises signals from part of the building.

# Network trouble list: which part of the building is cut off?
links = {("main", "east"): "ok", ("east", "plant"): "ok", ("plant", "north"): "open",
         ("north", "west"): "open", ("west", "south"): "ok", ("south", "emerg"): "ok", ("emerg", "main"): "ok"}
up = {n: set() for n in ["main", "east", "plant", "north", "west", "south", "emerg"]}
for (a, b), st in links.items():
    if st == "ok":
        up[a].add(b); up[b].add(a)
seen, todo = {"main"}, ["main"]
while todo:
    n = todo.pop()
    for m in up[n] - seen:
        seen.add(m); todo.append(m)
cut = sorted(set(up) - seen)
print("nodes reachable from the main panel:", sorted(seen))
print("nodes cut off:", cut if cut else "none")

nodes reachable from the main panel: ['east', 'emerg', 'main', 'plant', 'south', 'west']
nodes cut off: ['north']

Two open links isolate the north wing completely. The north wing node still runs its own detectors and signals, but the main annunciator and the monitoring center won't hear from it until a link is repaired. Two separate faults are what the ring is meant to survive only one of, which is why a single network trouble must be fixed promptly.

Annunciators, workstations and gateways

Networks also connect annunciators and graphic workstations. An annunciator at the fire department entrance shows every event on the network; a workstation in a security office shows events on a floor plan and lets trained staff acknowledge and silence. Some workstations can also send commands, which is why access to them must be controlled. Gateways connect the fire alarm network to other systems, such as building automation, mass notification or a campus monitoring system. A gateway that only sends information out is very different from one that can accept commands, a point taken up in the next lesson.

Programming a network

On a network, a change to one node's program can affect others: a new output on the north wing node that follows an alarm on the west tower node, or a new annunciator point that must appear on the main panel. Most systems keep a network database that ties the node programs together, and the technician must make sure every node is updated from the same version of the database. A node left with an older program may still run but ignore events it should act on, a fault that only shows up in a full test. After any change, the technician confirms each node's program version and tests the network functions the change affects.

# Do all nodes run the same network database version?
nodes = {"main": "2026.04b", "east": "2026.04b", "plant": "2026.04b", "north": "2026.03a",
         "west": "2026.04b", "south": "2026.04b", "emerg": "2026.04b"}
from collections import Counter
current = Counter(nodes.values()).most_common(1)[0][0]
for n, v in nodes.items():
    print(f"{n:6s} {v}  {'' if v == current else '<- older program, update and retest'}")

main   2026.04b  
east   2026.04b  
plant  2026.04b  
north  2026.03a  <- older program, update and retest
west   2026.04b  
south  2026.04b  
emerg  2026.04b

Testing a network

Network testing has three parts. First, each node is tested like any panel. Second, network functions are tested: an alarm on each node appears on every annunciator and workstation that should show it, and operates every output on other nodes that the sequence calls for. Third, network faults are introduced: each network link is opened and shorted, and for fiber each fiber is disconnected, to confirm that the trouble is reported, that messages still get through the other way, and that the trouble restores when the link is repaired. The monitoring center is told before the test, because network troubles are sent off the premises.

Fiber links between buildings

At Eastview, the central plant node is in a separate building connected to the main hospital by an underground tunnel, and its network link is fiber. Fiber has no metal path for lightning or ground differences between buildings, and it can run much further than copper. It needs care, though: the fiber type, connectors and power budget must match the network cards' requirements, splices and patch panels must be documented, and the fiber's supervision must report a loss of light. The low-voltage program's fiber course covers the installation and testing; the fire alarm technician's part is to use fiber and converters listed for the fire alarm network, and to confirm that disconnecting each fiber produces the expected network trouble.

# Fiber link loss budget for the plant-to-main network link (illustrative values)
length_km, loss_per_km = 0.42, 3.5            # multimode at the card's wavelength
connectors, loss_per_connector = 4, 0.75
splices, loss_per_splice = 2, 0.3
budget_db = 8.0                                # from the network card's data sheet
loss = length_km * loss_per_km + connectors * loss_per_connector + splices * loss_per_splice
print(f"calculated loss {loss:.2f} dB of {budget_db} dB budget, margin {budget_db - loss:.2f} dB")

calculated loss 5.07 dB of 8.0 dB budget, margin 2.93 dB

Network wiring classes

Network circuits between nodes are installed to the pathway class the design calls for, often the highest class the system offers, because a network fault affects far more than one device. The design also considers survivability: whether the network cable must be protected from fire in some parts of the building so that the network keeps working while a fire burns in another area, for example in high buildings and in systems that carry voice evacuation. Where the cable must survive a fire, the design specifies a rated cable or a protected route, and the installer follows it exactly.

When the network is extended, as it was for the north wing, the new link is installed and tested before it is connected, and then the ring is closed and every node's network status is checked. A ring that has been opened to add a node and not closed properly is a common finding at the next inspection.