TSN IEEE 802.1Q Time-Sensitive Networking Architecture Guide 2026
A standard Ethernet switch can delay a 100-byte control frame by more than 12 microseconds simply because a 1,500-byte file-transfer frame started transmitting one nanosecond earlier. Across five hops that is a 60 microsecond swing, which is fatal for a servo loop running a 250 microsecond cycle. This is the problem that Time-Sensitive Networking solves, and the TSN IEEE 802.1Q time-sensitive networking architecture guide you are reading explains how the pieces fit together in 2026.
It matters now for two reasons. The standards stack has finally consolidated: the core features live inside IEEE 802.1Q-2022, and the industrial profile IEC/IEEE 60802 was published in mid-2026 according to the IEEE 802.1 working group page. At the same time, OPC UA FX is making TSN the default transport for controller-to-controller and controller-to-device traffic.
You will leave with a layered mental model, the exact job of each amendment, a worked guard-band and latency budget you can adapt, the three 802.1Qcc configuration models, and runnable Linux configurations for gPTP, taprio, ETF and frame preemption.
What this covers: the problem TSN solves, the layered architecture, time synchronization, scheduling and shaping, preemption, per-stream protection, redundancy, configuration, the 60802 profile, a worked latency calculation, OPC UA over TSN, Linux support, failure modes and a deployment checklist.
Context and Background
Ethernet was built for statistical sharing. Every switch port has a handful of queues, a strict-priority or weighted scheduler, and nothing that knows what time it is. Under light load this behaves beautifully. Under contention the worst-case delay of a high-priority frame is bounded only by the size of whatever is already on the wire plus whatever sits ahead of it in the same queue, and neither number is something a control engineer can promise.
Industrial automation answered this twenty years ago with proprietary real-time Ethernets. PROFINET IRT reserves time slots with specialised ASICs, EtherCAT processes frames on the fly in every device, and CC-Link IE and others use their own conventions. They work, but each is its own island with its own tooling, and converging them with IT traffic means separate cabling or careful gateways. Our comparison of PROFINET, EtherCAT and OPC UA FX over TSN covers where each still wins.
TSN is the IEEE 802.1 answer: a toolbox of independent, composable amendments that add bounded latency, bounded jitter and loss-free delivery to ordinary Ethernet bridging. The word toolbox matters. TSN is not one protocol. You can use gPTP alone for time distribution, add the time-aware shaper for scheduled traffic, add per-stream filtering for protection, and add frame replication for redundancy, each independently. The IEEE 802.1 working group maintains the authoritative project list at the TSN task group page.
Two consolidation steps shape how you should read the standards today. IEEE 802.1Q-2018 rolled up 802.1Qbu (preemption), 802.1Qbv (time-aware shaper), 802.1Qci (per-stream filtering and policing), 802.1Qch (cyclic queuing and forwarding) and others into the base bridging standard. IEEE 802.1Q-2022 then rolled up 802.1Qcc (stream reservation enhancements and configuration), 802.1Qcr (asynchronous traffic shaping) and further amendments. So when someone says “802.1Qbv” they mean a clause of 802.1Q, not a separate live document. Standalone standards still exist for 802.1AS-2020 (timing) and 802.1CB-2017 (redundancy), plus amendments such as 802.1CBdb. A new 802.1Q revision was listed as in progress at the time of writing.
The newest development is profiling. Raw TSN offers so many options that two compliant products may not interoperate. Profiles select the options: IEEE 802.1BA for audio-video, IEEE 802.1DG-2025 for automotive in-vehicle Ethernet, and IEC/IEEE 60802 for industrial automation. The latter is the one this site’s readers care about most. For the timing fundamentals underneath, see our guide to PTP IEEE 1588 versus NTP and chrony.
One caveat on the earlier version of this article: it described gPTP in terms of boundary and transparent clocks. That vocabulary belongs to the IEEE 1588 default and power profiles. 802.1AS uses a different model in which every bridge is a time-aware system that terminates and regenerates sync, and this version corrects that.
The TSN Reference Architecture
TSN is best understood as six layers that each remove one source of nondeterminism: unknown time, unknown queuing, unknown blocking, unknown misbehaving talkers, unknown failures and unknown configuration. A bridge that implements all six can offer a bounded, protected, redundant path for a named stream.

Figure 1: The TSN layer model. Time is the foundation, shaping and preemption bound latency, Qci and FRER protect and replicate, and Qcc plus the 60802 profile configure everything from one place.
The diagram shows dependencies, not a protocol stack. Almost every feature depends on the time layer, because a gate that opens at “t = 500 microseconds” is meaningless unless every bridge agrees what 500 microseconds is. The shaping layer sits in the middle because it is where frames are actually admitted to the wire. Configuration reaches into every other layer, which is why centralised configuration is the hardest part of a real deployment.
Layer 1: Time, 802.1AS gPTP
IEEE 802.1AS-2020 is the generalized Precision Time Protocol profile. It is a constrained profile of IEEE 1588, with a fixed set of choices that remove the configuration freedom of full PTP. Messages travel directly over Layer 2 using EtherType 0x88F7 and the multicast address 01-80-C2-00-00-0E, so no IP stack is needed in a switch. Link delay is measured with the peer-to-peer mechanism (Pdelay_Req, Pdelay_Resp), which means each link measures its own propagation delay independently of which port is currently receiving time.
Each bridge is a time-aware system: it receives Sync and Follow_Up on its slave port, adds the measured link delay and its own residence time, and generates fresh Sync messages on its master ports. There is no transparent-clock correction field arithmetic across multiple hops in the way an end-to-end 1588 profile does it. The practical consequence is that error accumulates per hop through the chain of regenerated sync messages, and the original 802.1AS design goal of 1 microsecond over seven hops reflects that. Industrial profiles tighten this considerably, as the 60802 section below explains.
The best master clock algorithm (BMCA) picks the grandmaster using the priority and clock-quality fields in Announce messages. 802.1AS-2020 added support for multiple simultaneous time domains, which is how an industrial network can carry a global time (traceable to UTC) and a separate working clock for machine cells at the same time. Hot-standby grandmasters were still being defined in an 802.1ASdm project at the time of my last check, so treat seamless grandmaster redundancy as vendor specific for now.

Figure 2: gPTP message flow. Sync and Follow_Up cascade hop by hop from the grandmaster, while every link independently measures its own delay with Pdelay exchanges.
Figure 2 shows the two flows that matter. The downward cascade carries the time. The sideways Pdelay exchanges happen continuously on every link, including links that are blocked from carrying time, so a topology change does not require re-measuring delay before time can flow again. That is a real advantage over end-to-end delay measurement.
Layer 2: Shaping, 802.1Qbv and 802.1Qav
Two shapers provide bounded queuing delay, and they solve different problems. The credit-based shaper (CBS) from 802.1Qav, now part of 802.1Q, limits the rate of a stream class using credit that accrues at an idle slope and drains at a send slope. It needs no clock, which makes it the right tool for audio-video and for soft real-time flows. Stream Reservation Class A targets two milliseconds over seven hops and class B targets 50 milliseconds, per the AVB profiles. CBS bounds latency statistically as long as every talker honours its reservation, but it cannot give microsecond-level guarantees because a frame may still wait behind a burst.
The time-aware shaper (TAS) from 802.1Qbv adds a transmission gate to each of a port’s eight queues. A gate control list (GCL) is a cyclic table of entries, each saying which gates are open for how many nanoseconds. A base time anchors the first cycle to the synchronized clock, and the cycle time sets the repetition. When gate 7 is open and all others are closed, only traffic class 7 may transmit, and nothing can interfere with it. That is the mechanism that converts “high priority” into “guaranteed”.
We cover the scheduling algorithms, gate list construction and typical cycle structures in depth in our dedicated post on the 802.1Qbv gate control list scheduling. Here we focus on how it composes with the other layers.
Layer 3: Blocking, 802.1Qbu and 802.3br
The time-aware shaper has a flaw. Before a protected window opens, the bridge must stop starting new lower-priority frames, because a frame that began 1 nanosecond before the window would run into it. The required gap is a guard band of one maximum-size frame time. Frame preemption removes most of that cost. IEEE 802.3br defines how a MAC can split a preemptable frame into fragments and interleave an express frame, and 802.1Qbu defines how bridges choose which queues are express and which are preemptable.
Express frames use the normal start-of-frame delimiter. Fragments of preemptable frames use SMD-S and SMD-C delimiters with a fragment counter, and each fragment ends with its own 4-byte check value (mCRC) except the last, which carries the original FCS. Before preemption is enabled on a link, a verify handshake confirms the link partner can reassemble, so enabling it blindly against a legacy neighbour does not corrupt traffic. The minimum fragment size is configurable, and the maximum express-frame hold-off is on the order of 124 octets, which is roughly one microsecond at 1 Gb/s.
Layer 4: Protection, 802.1Qci per-stream filtering and policing
Scheduling guarantees only hold if talkers behave. 802.1Qci (PSFP) places three checks at the bridge ingress, bound to a stream by a stream handle. A stream filter matches on the stream and priority and can enforce a maximum SDU size. A stream gate is a time-based gate, driven by the same synchronized clock, that passes frames only in their expected window. A flow meter applies a two-rate, three-colour token-bucket policer with optional colour awareness, drawn from the MEF 10.3 model.
The effect is containment. A babbling-idiot talker, a firmware bug that doubles the transmission rate, or a malicious injection in the wrong window is dropped at the first bridge instead of consuming the protected window downstream. It is also a defence-in-depth control that application security cannot replace: the certificates and policies in our OPC UA security hardening guide authenticate a sender but cannot stop a network flood.
Layer 5: Reliability, 802.1CB FRER
Frame Replication and Elimination for Reliability sends duplicate copies of each frame along disjoint paths and removes the duplicates at the merge point. A sequence generation function inserts a sequence number, carried in a 6-byte redundancy tag (R-TAG, EtherType 0xF1C1), on the replicating node. Stream identification functions (null stream, source MAC and VLAN, active destination MAC and VLAN, and IP stream identification) tell bridges which frames belong to which stream. A sequence recovery function discards duplicates using either a vector algorithm or a match algorithm, and an individual recovery function can handle each member stream separately.
The result is zero-recovery-time failover. When a link breaks, the surviving copy simply keeps arriving, so no spanning tree or ring protocol must reconverge. Compare that with the several-millisecond to tens-of-milliseconds behaviour of MRP and RSTP covered in our post on PRP, HSR and MRP ring redundancy. The price is doubled bandwidth for protected streams and a requirement that the two paths really are disjoint.
Layer 6: Configuration, 802.1Qcc
All of the above produce per-port, per-stream state: gate lists, stream identification tables, meter parameters, sequence recovery settings. Configuring that by hand across dozens of bridges is infeasible and error-prone. 802.1Qcc, now in 802.1Q-2022, defines the roles and models for doing it. The next sections go deep on that model, but the headline is that a Centralized Network Configuration entity (CNC) computes the schedule and pushes it with NETCONF and YANG.
A follow-on amendment, IEEE 802.1Qdj-2024, which the 802.1 project list shows as current, adds configuration enhancements for TSN. Check its scope before assuming your CNC supports it.
Configuration Models: 802.1Qcc CNC, CUC and the Three Topologies
The direct answer: 802.1Qcc defines three ways to configure TSN streams. In the fully distributed model, talkers and listeners signal with the Stream Reservation Protocol and bridges decide locally. In the centralized network, distributed user model, a CNC computes bridge configuration while end stations still use SRP. In the fully centralized model, a CUC collects stream requirements and a CNC computes and provisions everything.
Industrial networks overwhelmingly use the fully centralized model, because only a global view can compute non-conflicting gate lists. The distributed model works for audio-video bridging where classes are statistical, but a time-aware schedule is a global optimisation problem: the transmission offset chosen for a stream at hop one determines what window must be open at hop four.

Figure 3: Fully centralized configuration. The CUC translates application needs into talker and listener groups, the CNC computes schedules and provisions bridges through NETCONF and YANG, and status flows back up.
What each entity actually does
The Centralized User Configuration (CUC) knows about applications and end stations. It discovers devices, learns which talker produces which data set at what interval, and creates a join request containing a talker group (stream identity, interval, maximum frames per interval, maximum frame size, earliest and latest transmit offset) and listener groups (accumulated latency requirements). In an OPC UA FX system, the CUC role is typically played by or integrated with the engineering tool, which is an open interoperability question in itself.
The Centralized Network Configuration (CNC) knows the topology, learned through LLDP and bridge management, and per-port capabilities such as link speed, propagation delay, queue count, GCL length limit, and whether preemption or FRER is supported. Given the join requests it must solve three problems: find a path (or two disjoint paths for FRER), assign each stream a transmission offset and window, and generate a consistent GCL for every egress port on every path. It then provisions with NETCONF using the YANG modules from 802.1Q (for example the scheduled-traffic and stream-filter models) and reports success or a failure code back to the CUC.
Why the schedule problem is hard
Computing a feasible schedule is a variant of job-shop scheduling and is NP-hard in the general case. Real CNCs use heuristics, SMT solvers or constraint programming, and published research shows that solvers handle hundreds of streams but slow sharply beyond that. Scalability and runtime schedule changes are the main differences between CNC products today. A practical consequence: when adding a stream to a running plant, ask whether your CNC can do incremental scheduling that leaves existing streams untouched, or whether it re-solves everything and re-provisions every bridge.
Two scheduling styles are common. In windowed or per-stream scheduling each stream gets its own gate window per hop, giving the lowest latency but the largest GCLs. In cyclic queuing and forwarding (802.1Qch) all bridges follow one simple alternating pattern with two queues, trading a latency of one to two cycles per hop for tiny gate lists and trivial computation. Asynchronous traffic shaping (802.1Qcr) avoids network-wide time altogether for flows that can tolerate more latency, using per-stream shaping in the style of urgency-based schedulers. A pragmatic design uses TAS for the hard isochronous class and ATS or CBS for the rest.
The IEC/IEEE 60802 Industrial Profile
IEC/IEEE 60802 selects TSN options for industrial automation so that devices from different vendors converge on one configuration. According to the IEEE 802.1 working group page it is listed as published on 29 June 2026 as IEC/IEEE 60802-2026. The page also shows an older PAR expiry date, an inconsistency I could not resolve from public sources, so check the IEEE store entry for the authoritative edition.
The profile is a joint IEC SC 65C WG 18 and IEEE 802 project, with its PAR approved in September 2022 according to the same page. It builds on 802.1Q, 802.1AS and 802.1CB, adds industrial requirements, and gives guidance for converged networks where OT traffic shares links with IT traffic. The public page did not list detailed requirement values, so the following points come from the working group’s contribution topics and general profile structure, and I flag specifics as unverified where they come from draft-era recollection.
What the profile standardises
Several themes recur in the working-group contributions listed on the page: normative time-synchronization requirements including mean link delay averaging and neighbor rate ratio tracking, YANG module selection and content, NETCONF over TLS 1.3 for management security, Secure Device Identity (IEEE 802.1AR) for device authentication, and the CUC-CNC interaction. These match the real pain points. Interop failures in early TSN deployments were rarely in the shaper; they were in synchronization accuracy, and in each vendor’s private configuration interface.
From earlier drafts, the profile organises traffic into classes such as isochronous cyclic, cyclic synchronous, cyclic asynchronous, alarms and events, configuration and diagnostics, network control and best effort (unverified against the published text). It targets line, ring and tree topologies with a large maximum bridge count and shorter cycle times than IT networks expect (unverified; the draft-era figures I recall were tens of bridges and cycle times from tens of microseconds to tens of milliseconds, and I did not confirm the final values).
What it means for you
For procurement, “60802 conformant” will become the term to ask for, alongside OPC UA FX conformance. Expect conformance testing programs from industry groups to follow publication; I did not verify any specific test or certification program availability. For design, assume that profile-conformant bridges will support gPTP with multiple domains, at least a defined number of gate-control entries and stream-filter instances per port, and the Qcc fully centralized model with NETCONF. Where a vendor claims TSN but exposes only a proprietary web GUI for schedules, you have a lock-in problem that the profile exists to remove.
Related profiling work includes IEEE 802.1DG-2025 for automotive in-vehicle networks, which the IEEE site lists as published. Its option choices differ from 60802 because vehicles have fixed topologies and use static configuration, which is a useful reminder that profiles encode context. Our post on SOME/IP and service-oriented vehicle architecture shows what runs on top.
Worked Example: Guard Band, Window and Latency Budget
This example uses illustrative numbers, labelled as such, to show how the pieces combine. Assume a 1 Gb/s network (8 ns per byte), a 1 ms cycle, three bridges between a PLC talker and a drive listener, and eight isochronous streams per cycle carrying 100 bytes of payload each.
Step 1: frame times. A VLAN-tagged frame with 100 bytes of payload is 14 (header) + 4 (tag) + 100 + 4 (FCS) = 122 bytes. Add 8 bytes of preamble and 12 of inter-frame gap and it occupies 142 byte times on the wire, which is 1,136 ns. A maximum-size tagged best-effort frame is 1,522 bytes, plus 20 bytes of preamble and gap, giving 1,542 byte times or 12,336 ns, call it 12.34 microseconds.
Step 2: guard band without preemption. The best-effort gate must close 12.34 microseconds before the protected window opens, because a maximum frame that starts just before closure must finish. This guard band is lost bandwidth on every protected window on every port. If the eight streams share one contiguous window, the window is 8 × 1.136 = 9.09 microseconds. Window plus guard is 21.4 microseconds out of 1,000, which is 2.1 percent of the cycle.
Step 3: add the synchronisation margin. Suppose the gPTP error between two neighbouring bridges is up to 250 ns. A gate may open 250 ns early or late relative to its neighbour, so the window needs about 250 ns of margin at each end, or 0.5 microseconds in total. The protected window grows to about 9.6 microseconds. The margin scales with clock error, not with frame size, so synchronisation quality translates directly into usable bandwidth.
Step 4: per-hop latency across designs. Take 3 µs of bridge processing and 0.5 µs of propagation (100 m of cable at about 5 ns per metre) per hop, plus 1.136 µs to serialise the frame. The base per-hop cost with no waiting is 4.64 µs.
| Design | Worst wait per hop | Per-hop total | Three hops |
|---|---|---|---|
| Strict priority only, no TAS, no preemption | 12.34 µs, one max frame already in flight | 16.98 µs | 50.9 µs |
| Strict priority with preemption | about 1 µs hold-off | 5.64 µs | 16.9 µs |
| TAS, schedule aligned, guard band 12.34 µs | 0 | 4.64 µs | 13.9 µs |
| TAS, schedule aligned, preemption, guard band about 1 µs | 0 | 4.64 µs | 13.9 µs |
| TAS, schedule misaligned by a late frame | up to one full cycle, 1,000 µs | about 1,005 µs | about 3,000 µs |
The table makes three points. First, preemption alone cuts blocking by an order of magnitude without any schedule. Second, a correctly aligned TAS gives the lowest latency and the same figure with or without preemption, because the guard band protects the window; preemption’s gain there is bandwidth, since the guard band shrinks from 12.34 µs to about 1 µs. Third, a misaligned schedule is catastrophic: a frame that misses its window waits for the next cycle. That is why Qci stream gates and accurate gPTP matter as much as the shaper itself.
Step 5: the same arithmetic at 100 Mb/s. Many field devices still run 100 Mb/s. Now the maximum frame is 123.4 µs, and the guard band would consume 12.3 percent of a 1 ms cycle on every protected port. On a 250 µs cycle it would consume nearly half. Preemption becomes close to mandatory here: the hold-off of roughly 124 octets is about 10 µs at 100 Mb/s, so the guard band drops by more than an order of magnitude. This is the economic argument for preemption in machine-level networks, which is why 802.3br support is a selection criterion for field-level silicon.
Step 6: end-to-end budget. The total worst-case latency for the stream is the sum of per-hop delays plus the talker’s launch offset uncertainty and the listener’s processing time. Compare the sum with the application’s cycle time and its tolerance (typically one cycle, often less). A useful rule: leave at least 30 percent of the cycle unallocated for future streams and for synchronisation drift under fault conditions. All figures above are illustrative; real bridge latency, guard-band handling and hold-off differ by silicon.
OPC UA FX and PubSub over TSN
OPC UA FX (Field eXchange) is the OPC Foundation’s initiative to give the factory floor a vendor-neutral data model on top of a deterministic transport. The relevant specification parts sit in the OPC 10000-80 to 84 series, with Part 84 covering profiles; we track the revision differences in OPC UA FX v1.00.04 versus v1.00.03 and the architecture in the OPC UA FX reference architecture. The OPC Foundation reference site lists Part 84 at version 1.00.04.
The real-time data path uses OPC UA PubSub (Part 14) with the UADP message mapping directly over Ethernet, not over UDP/IP. A WriterGroup defines the publishing interval and, in the TSN case, the offset within the cycle. DataSetWriters in the group publish DataSetMessages, and a DataSetReader on the subscriber filters by publisher ID, writer group ID and dataset writer ID. Because the transport is a Layer 2 multicast stream with a VLAN priority, it maps cleanly to a TSN stream with a stream handle, and a CNC can treat each WriterGroup as a talker.
The cleanest way to think about the split is: OPC UA FX defines what streams are needed (the talker and listener requirements, derived from connections between function blocks), and TSN defines how they are carried. The CUC role translates FX connection requirements into 802.1Qcc join requests. Our post on OPC UA PubSub with MQTT versus UADP covers when to use each mapping: MQTT for cloud and unified-namespace flows, UADP-over-Ethernet for deterministic control.
I did not verify the precise engineering-tool workflow by which a given vendor implements the CUC for FX, nor any interoperability plugfest results. Treat vendor claims of “FX over TSN” as needing a test with your own bridge and controller combination.
Where TSN sits against alternatives
TSN is not the only way to get determinism. Private 5G offers wide-area mobility with different latency guarantees, and our private 5G versus Wi-Fi 7 versus TSN decision guide and TSN versus 5G URLLC comparison explore that boundary. A wired TSN backbone with 5G or Wi-Fi as a bridged segment is a common pattern, with the wireless segment appearing as a TSN-aware link whose delay variation is accounted for in the budget.
Linux Support: ptp4l, taprio, ETF and Frame Preemption
Linux gives you a credible TSN endpoint and a usable software bridge for lab work. The pieces are linuxptp for gPTP, the taprio qdisc for the time-aware shaper, the etf qdisc and SO_TXTIME for launch-time transmission, the cbs qdisc for credit-based shaping, the gate action for 802.1Qci, and the ethtool MAC-merge interface for preemption. Hardware offload depends on the NIC driver, so verify with your specific part.

Figure 4: The Linux endpoint stack. ptp4l disciplines the NIC’s hardware clock, phc2sys aligns the system clock, taprio schedules traffic classes against CLOCK_TAI, and etf releases frames at their launch time.
Step 1: synchronise with ptp4l
Linuxptp ships a gPTP configuration file. The essential settings are layer-2 transport, peer-to-peer delay, hardware timestamping and the 802.1AS transport specific field.
# gPTP.cfg (based on the linuxptp gPTP.cfg sample)
[global]
gmCapable 1
priority1 248
priority2 248
transportSpecific 0x1
time_stamping hardware
network_transport L2
delay_mechanism P2P
logSyncInterval -3
logAnnounceInterval 0
neighborPropDelayThresh 800
# Run gPTP on eth0
ptp4l -i eth0 -f gPTP.cfg -m
# Copy PHC time to CLOCK_REALTIME and keep the TAI offset right
phc2sys -s eth0 -c CLOCK_REALTIME --transportSpecific=1 -w -m
The -w flag makes phc2sys wait for ptp4l to reach a synchronised state and pick up the UTC offset from it, which sets the kernel’s TAI offset. This matters because taprio schedules against CLOCK_TAI. If the TAI offset is wrong by the 37 seconds that separate TAI from UTC, every gate opens 37 seconds off, and the symptom is a silent link that looks dead rather than an error.
Step 2: the time-aware shaper with taprio
This configuration creates three traffic classes on a four-queue NIC and opens them in a repeating 1 ms cycle. Priority 3 maps to class 0 (isochronous), priority 2 to class 1, and everything else to class 2. Adjust queue counts to your hardware.
# Replace the root qdisc with taprio, full hardware offload (flags 0x2)
tc qdisc replace dev eth0 parent root handle 100 taprio \
num_tc 3 \
map 2 2 1 0 2 2 2 2 2 2 2 2 2 2 2 2 \
queues 1@0 1@1 2@2 \
base-time 1700000000000000000 \
sched-entry S 01 100000 \
sched-entry S 02 200000 \
sched-entry S 04 700000 \
flags 0x2 \
clockid CLOCK_TAI
Each sched-entry is a command (S sets gate states), a hexadecimal gate mask for traffic classes and an interval in nanoseconds. The three intervals sum to 1,000,000 ns, the cycle time. The base-time is an absolute TAI timestamp in nanoseconds; choose one in the future that is a whole multiple of the cycle from your plant epoch so all nodes agree on cycle phase. Without hardware offload (flags 0x1 is txtime-assist mode, no flags is software), jitter is bounded by Linux scheduling, typically tens of microseconds, so use offload for anything below that.
Step 3: launch-time control with etf and SO_TXTIME
For a talker that must emit at exact instants, add the earliest-txtime-first qdisc below a taprio class, and set the transmit time on each packet.
tc qdisc replace dev eth0 parent 100:1 etf \
clockid CLOCK_TAI delta 150000 offload
/* Enable SO_TXTIME on the socket, then stamp each packet */
struct sock_txtime cfg = { .clockid = CLOCK_TAI,
.flags = SOF_TXTIME_REPORT_ERRORS };
setsockopt(fd, SOL_SOCKET, SO_TXTIME, &cfg, sizeof(cfg));
uint64_t txtime = next_cycle_start_ns + stream_offset_ns;
/* attach txtime via a SCM_TXTIME control message in sendmsg() */
The delta is how far ahead of the launch time the qdisc hands the frame to the driver, and must exceed your worst-case software path latency. The offload flag asks the NIC to hold the frame until the launch time, which requires a NIC with launch-time support. Intel’s i210 family is commonly used for launch-time work and the i225 and i226 for taprio offload, but support varies by driver and silicon revision, and I did not verify current driver status.
Step 4: credit-based shaping, preemption and ingress gating
# Credit-based shaper for an AVB class on a hardware queue
tc qdisc replace dev eth0 parent 100:2 cbs \
idleslope 20000 sendslope -980000 hicredit 30 locredit -1470 offload 1
For a 1 Gb/s link, idleslope is the reserved rate in kb/s and sendslope equals idleslope minus the port rate, which gives the -980,000 above. For preemption, recent kernels expose the MAC merge layer through ethtool and mark express versus preemptable classes in the shaper. I believe this arrived around kernel 6.7 but did not verify the exact release, so check your kernel’s documentation.
# MAC merge (frame preemption) with verification
ethtool --set-mm eth0 pmac-enabled on tx-enabled on verify-enabled on \
tx-min-frag-size 60
ethtool --show-mm eth0
# Per-traffic-class express (E) or preemptable (P), on taprio
# ... taprio ... fp E P P ...
Ingress policing by 802.1Qci maps to the tc gate action on a flower filter in the Linux kernel, which can implement a time-based gate on a stream, combined with a policer for the rate. FRER (802.1CB) has no general mainline Linux implementation that I could verify, so on Linux you generally rely on switch silicon or vendor stacks, or use application-level redundancy such as PRP at the NIC. Switch chips from vendors such as NXP offer TSN features with Linux drivers in the kernel tree, but check the feature-by-feature support for the part you plan to buy.
Verifying it works
Never trust a schedule you have not measured. Use hardware timestamps on the receiver and plot inter-arrival times over a long run. Linux tools include the linuxptp utilities (pmc to query offsetFromMaster and the path delay), and a cyclictest-like application that reports end-to-end jitter. Watch the ptp4l offset: if it ever exceeds the margin you added in the worked example, the failure appears as occasional missed windows, which are miserable to diagnose after the fact. Log gPTP offset and gate-miss counters together.
Trade-offs, Gotchas, and What Goes Wrong
The most common TSN failure is not a protocol bug but a synchronisation one. Gate lists assume a shared clock, so a grandmaster change, a flapping link or a bridge with poor oscillators shifts windows relative to each other. Frames then arrive just outside their windows and wait a full cycle, as the misaligned row in the worked example shows. Monitor gPTP offset and neighbour rate ratio on every hop, alarm well before the margin is consumed, and decide in advance what the network does on loss of time: Qci stream gates that rely on synchronised time can start dropping legitimate traffic, so define a safe fallback.
Second, configuration complexity bites. A GCL on every egress port, stream identification tables, meters and sequence recovery state add up to thousands of parameters. Vendors differ on maximum GCL length, number of stream filters, and whether gates can change atomically at a cycle boundary. A schedule that is perfectly valid on paper may not be installable on the cheapest bridge in the path. Inventory capabilities with the CNC before design, not after.
Third, bandwidth arithmetic is unforgiving. Guard bands, synchronisation margins and the reserved share for FRER duplicates all consume capacity. On 100 Mb/s links without preemption the overhead can dominate. FRER doubles the bandwidth of protected streams, and the two paths must be genuinely disjoint, which a ring with one shared uplink is not.
Fourth, brownfield coexistence. Every non-TSN device in the path is a source of unbounded delay, and a single legacy unmanaged switch in the middle silently voids the guarantee. Preemption must be enabled symmetrically and verified at each link, and mixed 100 Mb/s and 1 Gb/s networks need separate worst-case calculations per link speed.
Fifth, security is an open design question. TSN gives you Qci to contain misbehaving talkers, and 60802 work points to NETCONF over TLS and device identities, but the management plane that can rewrite every gate list is a very high-value target. Protect the CNC like a domain controller. An attacker who can push a schedule can cut off any stream, and an attacker who can disturb gPTP can degrade the whole network at once. Anti-patterns to avoid: one giant flat TT class for everything, hand-edited gate lists on production bridges, ignoring cable asymmetry in delay measurement, and deploying TSN without a measurement plan.
There are also honest limits. TSN is a Layer 2 technology, so it is bounded to a bridged domain, and crossing routers needs separate mechanisms such as the work in the IETF DetNet group. Software endpoints on general-purpose Linux give microsecond-scale rather than nanosecond-scale jitter unless you use offload. And PROFINET IRT and EtherCAT remain simpler for single-vendor cells where convergence is not a requirement. TSN pays off when you need multi-vendor interoperability and converged IT/OT traffic.
Practical Recommendations
Start by deciding which TSN layers you actually need. A motion cell with a 250 microsecond cycle needs gPTP, the time-aware shaper, and probably preemption on 100 Mb/s links. A plant backbone carrying controller-to-controller traffic at 10 ms may be satisfied with gPTP, CBS or ATS and VLAN priorities, and does not need hand-built gate lists. A safety or high-availability stream adds FRER and Qci. Choosing the minimum subset reduces both cost and the number of things that can break.
Buy against profiles, not feature lists. Ask each vendor for the exact set of standards clauses, the maximum GCL length, the number of stream filters, supported gPTP domains, and the configuration interface (NETCONF with standard YANG, or proprietary). Prefer products that state IEC/IEEE 60802 alignment and have an OPC UA FX roadmap, and get written confirmation of the latency specification per hop at your link speed.
Build a measurement plan before you build the network. Capture hardware timestamps at the talker, at every bridge you can instrument, and at the listener, and keep a long-duration baseline. Test failure cases deliberately: unplug the grandmaster, break a FRER path, inject an over-rate stream and confirm Qci drops it.
Checklist:
- Define traffic classes, cycle times and latency budgets in writing, with a per-hop worked calculation like the one above.
- Confirm every bridge and end station supports the clauses you depend on, at your link speeds.
- Use the fully centralized Qcc model for scheduled traffic, and secure the CNC and CUC.
- Choose gPTP domains deliberately: one for global time, one for working clock if needed.
- Enable preemption only after the verify handshake succeeds on both ends.
- Leave at least 30 percent of cycle time unallocated for growth and fault margin.
- Monitor gPTP offset, gate-miss counters and Qci drop counters, with alarms.
- Keep non-TSN devices out of scheduled paths.
- Validate on a testbed with your exact bridge and controller combination before commissioning.
For adjacent decisions, our industrial communication protocols architecture guide places TSN alongside the rest of the protocol landscape, and the PROFINET IRT with TSN guide shows the migration path for existing PROFINET plants.
Frequently Asked Questions
What is the difference between TSN and IEEE 802.1Q?
IEEE 802.1Q is the base bridging and VLAN standard. TSN is the set of features within and alongside it that add timing, scheduling, reliability and configuration. Since 802.1Q-2018 and 802.1Q-2022 the major TSN amendments such as Qbv, Qbu, Qci and Qcc are merged into 802.1Q itself, while 802.1AS timing and 802.1CB redundancy remain separate standards. So TSN is not a separate network type but a capability set that a standard Ethernet bridge can implement in whole or in part.
Do I need 802.1Qbv and frame preemption together?
Not always. The time-aware shaper gives deterministic delivery on its own, but it needs a guard band equal to one maximum-size frame before each protected window. On 1 Gb/s that is about 12 microseconds, which is tolerable for cycles of a millisecond or more. On 100 Mb/s it is about 123 microseconds, so preemption, which shrinks the guard band to roughly the hold-off of 124 octets, becomes close to essential for short cycles.
What is the difference between gPTP and PTP?
gPTP is IEEE 802.1AS, a profile of IEEE 1588 designed for bridged local networks. It runs directly on Layer 2 rather than over UDP, uses only the peer-to-peer delay mechanism, makes every bridge a time-aware system that regenerates Sync messages, and supports multiple time domains in the 2020 edition. Full 1588 has several profiles and options, including end-to-end delay and transparent clocks, which gPTP deliberately removes to improve interoperability.
Is IEC/IEEE 60802 published?
The IEEE 802.1 working group page lists IEC/IEEE 60802-2026, the TSN profile for industrial automation, as published on 29 June 2026, and several standards-body catalogues list an edition 1.0 with the same date. The same page shows an earlier PAR expiry, so confirm the exact edition and status in the IEEE or IEC store before citing it in a specification or tender document.
How does OPC UA FX use TSN?
OPC UA FX uses OPC UA PubSub with the UADP encoding mapped directly to Ethernet for its real-time cyclic data. Each WriterGroup, with its publishing interval and offset, becomes a TSN stream that a CNC can schedule. FX defines the connections and data semantics between controllers and devices, while TSN supplies bounded latency and synchronisation. Specification Part 84 covers profiles; always check the current revision on the OPC Foundation reference site.
Can I run TSN on Linux?
Yes, for endpoints and lab bridges. Linuxptp provides gPTP, the taprio qdisc implements the time-aware shaper, the etf qdisc and SO_TXTIME give launch-time control, cbs implements credit-based shaping, and the gate action supports ingress gating. Hardware offload is needed for sub-microsecond accuracy and depends on NIC driver support. Mainline Linux has no general FRER implementation that I could verify, so redundancy typically comes from switch silicon or vendor software.
Further Reading
Internal:
- 802.1Qbv gate control list scheduling
- PROFINET vs EtherCAT vs OPC UA FX over TSN
- OPC UA FX reference architecture
- PTP IEEE 1588 vs NTP vs chrony
- TSN vs 5G URLLC deterministic networking
- PRP, HSR and MRP ring redundancy
External:
- IEEE 802.1 Time-Sensitive Networking task group
- IEC/IEEE 60802 TSN profile for industrial automation
- OPC UA FX Part 84 on the OPC Foundation reference site
Last updated November 2026.
By Riju — about

Pingback: IEC/IEEE 60802 TSN Profile: 7 Decisions Industrial Network Architects Must Make in 2026 - IoT Digital Twin PLM