IOT on a ControlLogix: Getting an Output Out Before the End of the Scan
A reject gate on a 1.2 m/s belt was firing about 21 mm behind where the vision system said it should, and the rung that drove it was correct. The gate output lived on a module with a 20 ms RPI, the logic that decided to reject ran early in a 20 ms task, and the value then sat in the output tag waiting for the connection’s next scheduled update — 17.4 ms of doing nothing, which at that belt speed is 21 mm of carton.
IOT is the instruction that stops the waiting. It overrides the requested packet interval of an output connection and sends fresh data over it immediately, and it resets that connection’s RPI timer at the same time. The operand is the output tag of an I/O module or a produced tag, the connection has to be open for the instruction to execute, and on a produced tag it also sends an event trigger to the consuming controller.
1756-L83E, v34, with the output module in a remote chassis on EtherNet/IP.
What it overrides, and what it does not
The thing being overridden is the connection schedule, not the program scan.
An output connection updates at its RPI, independently of your task, so the delay you are trying to remove is the gap between the rung writing the value and the connection’s next transmission. That gap has nothing to do with how fast your logic runs — a 2 ms task feeding a 20 ms connection still waits up to 20 ms — which is why lowering the task period does nothing for this problem and lowering the RPI everywhere costs you network bandwidth you may not have. The instruction sends the data now and restarts the interval, so the next scheduled update moves along with it rather than arriving straight afterwards. What it does not touch is output processing, which is a separate piece of overhead the controller performs at the end of a task for the I/O modules in the system; that one is controlled by the task’s own Disable Automatic Output Processing setting, or by the DisableUpdateOutputs attribute on the Task object, and turning it off reduces task overhead without making any individual output faster.
Two different mechanisms, two different manuals, one very similar-sounding name. The RPI is the one that decides when your value reaches the terminals.

The saving is never the scan. It is the wait between the rung and the connection’s next scheduled transmission.
Where the rung goes
Below the rung that writes the value. That is the whole rule and it is broken constantly.
Put the IOT above the logic that computes the output and everything still compiles, downloads and runs; the instruction dutifully sends whatever was in the output tag, which is the value the logic wrote on the previous scan. The machine works. It is simply always one task period behind, which on a 20 ms task is a 20 ms error that looks exactly like a slow sensor, a slow drive or a bad guess at belt speed — and the reason it survives commissioning is that nobody measures a 20 ms error when the thing they were fixing was a 17 ms one. In structured text the same discipline applies: write the bit, then call IOT(Local:5:O); on the following line. One IOT per connection per scan is enough; calling it in three places in the same routine sends three packets and buys you nothing.
Read the rung numbers, not the logic. The order is the bug.

Both versions run. The left one has been in service on somebody’s machine for years, one period behind, and nobody has noticed.
The produced-tag case, and the checkbox that has to be ticked
This is where the instruction earns more than a few milliseconds.
If the operand is a produced tag rather than a module’s output tag, the IOT sends the data and an event trigger to the consuming controller, which means the producer can wake an event task in the consumer on demand instead of the consumer polling for a change. For that to work, the Connection tab of the produced tag’s properties has a checkbox — Programmatically (IOT Instruction) Send Event Trigger to Consumer — and without it the data arrives and the event task never fires. The consumer side has rules of its own: only one consumed tag can trigger a specific event task, and when a consumed tag triggers it the task waits for all the data to arrive before it executes. How quickly it gets there depends on what is between the two controllers. Over the backplane, immediately. Over EtherNet/IP, immediately. Over ControlNet, within the actual packet interval of the consumed connection, which is not immediate and is the difference people trip over when they move a working design onto an older network. Produced and consumed tags between two ControlLogix controllers covers the connection itself, and unicast or multicast on an EtherNet/IP I/O connection covers the checkbox next door that decides how the traffic is addressed.
If several produced and consumed connections run between the same pair of controllers and one fails, they all fail. Combining the data into one structure is the usual answer.
Four places it will not do what you want
Each of these is written down, and each one has cost somebody a week.
It does not work in a ControlLogix redundancy system — the manual says the instruction does not function correctly there and should not be used, with no qualification and no workaround offered. It cannot go inside an Add-On Instruction; the AOI language guideline excludes IOT along with JSR, FOR, BRK and the SFC instructions, so an otherwise tidy reusable block cannot carry its own immediate output. It will not execute at all if the connection is not open, so a module that is inhibited, faulted or still coming up simply swallows the instruction. And on a CompactLogix 5380, ControlLogix 5580 or 5590 controlling 5069 I/O over a remote network, connections configured at the same RPI in the same backplane get grouped into a single packet — so an IOT on one of those tags may push data for the other modules in the group as well. The manual’s own fix is blunt and effective: make the RPI of the connection you care about not exactly equal to the others. Connection parameters and RPI when you add a module to the Ethernet card is where that number gets set.

The bottom row is the surprising one. An IOT aimed at one module can send data for its neighbours if they share an RPI.
The dead end: chasing the network
When an output is late, the network gets blamed and the network is usually fine.
The measurement that settles it takes ten minutes: note the time the logic sets the bit, note the time the field device responds, and compare the difference against the connection’s RPI rather than against the task period. If the delay is bounded by the RPI, an IOT fixes it and nothing else needs to change. If it is longer than the RPI and varying, the problem is upstream of the instruction — a connection timing out and re-establishing, a switch dropping frames, or a timeout multiplier set so the connection survives longer than anyone intends. The connection timeout multiplier on a 1756-EN2T covers that side. And if the delay is the mechanical answer rather than the electrical one, the arithmetic belongs with the conveyor, not the controller: gapping cartons before a scanner works through the speed and distance sums.
Find the one output on your machine where milliseconds turn into millimetres, check whether its IOT is above or below the rung that writes it, and measure the delay against the connection’s RPI before you change anything else.