IMDHMIControls LibraryShop main store

Troubleshooting

Robot PROFINET data reaches the PLC in one direction only

Drives and motion Published 6 min read

Short answer

The one-way symptom is a register-direction error, not a PROFINET limit: cyclic I/O carries both directions at once, but input and output are named from the robot's viewpoint. read_input_boolean_register works because it consumes the bank the PLC fills; write_input_boolean_register writes into that same receive bank, so nothing reaches the S7-1200. Write the robot's output registers and bind fresh PLC input tags to them.

On this page
  1. Why the link looks one-way when it is not
  2. Confirm the PLC-to-robot baseline still updates
  3. Move the return-path writes to output registers
  4. Bind PLC tags to the robot's output data
  5. Prove the return path with a boolean, then numbers
  6. Fix summary and the decision
  7. Questions asked

Your UR CB-series robot reads every value the S7-1200 sends, but the PLC never sees anything the robot sends, and the cause is the register class, not PROFINET. Cyclic I/O moves data in both directions in the same exchange, and input and output are named from the robot's viewpoint: read_input_boolean_register consumes the bank the PLC fills, so it works; write_input_boolean_register writes into that same receive bank, so the return values go nowhere. Point the robot's return-path writes at its output registers and bind fresh PLC input tags to the addresses the device configuration assigns them. Work through the checks in order: confirm the working direction, then the register class, then the PLC mapping, then the data types.

PROFINET's cyclic exchange, part of the IEC 61158 fieldbus profile, is bidirectional by construction. Every bus cycle, the IO controller (the S7-1200) delivers its output data to the IO device (the robot), and the robot delivers its input data back in that same cycle. The naming follows the device's viewpoint: data the robot receives is robot input data, and data the robot produces is robot output data. That is the whole trap. A robot program that writes an "input" register is writing into its own receive bank, the bank the PLC owns on the wire, so nothing it puts there can reach the controller.

Data path Robot-side register class S7-1200 process image
PLC to robot robot input registers PLC outputs (%Q)
Robot to PLC robot output registers PLC inputs (%I)

A running connection can carry valid data one way while the other direction sits static, and the link diagnostics stay green, because the exchange itself is healthy: the application is writing the wrong bank. The same two-way exchange, laid out field by field for a drive, is described in Control a PROFINET servo drive with cyclic telegram data.

Confirm the PLC-to-robot baseline still updates #

  1. Toggle one PLC command bit and watch the boolean the robot reads with read_input_boolean_register: it must follow both states.
  2. Send one integer and one non-integer float from the PLC, for example 12345 and 3.75 (illustrative test values), and compare them at the robot.
  3. If all three follow, leave the network settings, device name and module selection untouched; that leg is proven and stays as it is.

If those values have also stopped updating, the fault is no longer one-directional: repair the connection and the PLC output mapping first, because a dead baseline invalidates everything downstream of it.

Move the return-path writes to output registers #

The reported pattern is that write_input_boolean_register executes at the robot without raising a fault, yet the PLC value never moves. That is the expected behavior: the PLC has no input location that maps to the robot's input registers, so a robot write into them stays on the robot side of the wire. Switch every return-path write to the output-register variant of the same register function family: the write whose target is an output boolean register for bits, and the integer and float output-register writes for numbers. The exact function names sit in the robot's script-function reference alongside the register functions you already call, and the change is the register class, not new program logic.

Do not chase the robot's role as the cause. The robot is the IO device on this link and stays one; an IO device does not wait for permission to transmit, it places its input data into every cycle the controller drives. "The robot is the server" is not a one-way restriction, and nothing about the device configuration needs to change to let the robot talk.

How the symptoms sort out:

  • Robot reads PLC values from input registers: correct direction, leave that logic alone.
  • Robot writes an input register to send: wrong bank, write the mapped output register instead.
  • Robot output register changes on the pendant but the PLC input stays static: register class is now right, mapping is not, go to the mapping check below.
  • PLC raw input changes but the typed value is wrong: transport works, representation does not, go to the data-type check below.

Bind PLC tags to the robot's output data #

Robot output registers only reach the PLC if they are part of the cyclic data you selected when the robot's device description (GSDML) file was added to the PLC project's device configuration. Confirm that every output register the program writes falls inside that mapped range; if one does not, move the write to a mapped register or revise the device configuration and apply it before testing further.

The device configuration assigns the robot's output data to input addresses in the S7-1200 process image, and those are new tags: never the %Q addresses of the working direction. PLC outputs feed robot inputs, and robot outputs arrive at separate PLC inputs. The two address spaces can show similar-looking offsets, so an address that works as a PLC output must not be copied into a PLC input tag.

Worked example, boolean address arithmetic. The start byte comes from your device configuration; this example assumes byte 0. If the robot's boolean output registers are mapped from %I0.0, boolean output register n sits at byte n divided by 8, rounded down, at the remainder bit. Register 0 sits at %I0.0. Register 9 = 8 + 1, so byte 1, bit 1, which is %I1.1. Register 20 = 16 + 4, so byte 2, bit 4, which is %I2.4. If a tag points at a %Q0.x address copied from the working direction, it shows the PLC's own output image, not the robot.

Prove the return path with a boolean, then numbers #

Prove the boolean first because it carries no number-format ambiguity:

  1. Command one output boolean false, true, false from the robot program and watch the robot-side register first. If it does not change, execution is not reaching the write, or later logic overwrites the value.
  2. Watch the raw PLC input bit next: it must follow both states. If the robot-side value changes and the raw input does not, the fault is addressing, so return to the mapping check above.
  3. Then send two easily distinguished integers and confirm both arrive at the PLC tag with the values the robot wrote.
  4. Then send a non-integer float such as 3.75 and confirm it decodes to that value. If raw input bytes move but the number is nonsense, the tag's data type or field boundary does not match the configured module layout. Correct the layout and type; never compensate with scaling, and apply engineering-unit conversion only after the raw value decodes correctly.

One safety note: these registers are non-safety process data, so keep robot motion gated by the machine's safety functions and never let a PROFINET register bit stand in for a safety signal.

Fix summary and the decision #

  1. Keep the proven PLC-to-robot reads on input registers, unchanged.
  2. Replace write_input_boolean_register and its integer and float siblings with the output-register writes.
  3. Confirm every written output register sits inside the configured cyclic data range.
  4. Bind PLC tags to the fresh %I addresses from the device configuration, matching data types and field boundaries.
  5. Apply the configuration, run the robot program, and accept the link on three results: the commanded boolean toggles at the PLC, both integers arrive unchanged, and the float decodes correctly.

Then make the next silent failure loud: have the robot increment one integer output register continuously and alarm when the count freezes, following the pattern in How to create a SCADA PLC communication alarm for link loss.

Decision: the link was never one-way. The robot was writing its receive bank. Write output registers on the robot side, read fresh PLC input tags on the controller side, and verify boolean, then integer, then float. If a value still refuses to move after that, it is a mapping fault, not a protocol limit, and changing protocols will not fix a mapping fault.

Questions asked

Should I abandon PROFINET and use Modbus TCP instead?

No. Universal Robots controllers support both protocols, but switching discards a configured and proven PLC-to-robot path and leaves the direction mistake in place, because every fieldbus names its registers from the device side. The register fix is one script edit plus new PLC input tags; rebuilding on Modbus is a whole new configuration on both sides.

Where do I find the exact register function names and the register counts?

In the robot's script-function reference, which lists every boolean, integer and float register function with its direction, and in the PROFINET guide published for your controller generation: Universal Robots issues separate PROFINET guides for the CB3 and the e-Series. Check the register count the device description file exposes against the modules you selected in the PLC's device configuration, because a register outside the mapped range never reaches the bus.

Does the robot need to be the PROFINET master to send data back?

No. On this link the robot is the IO device, and per Universal Robots' own documentation the controller cannot act as a PROFINET client at all. An IO device does not need master rights to transmit: it places its input data into every bus cycle the IO controller drives, which is exactly how the PLC-to-robot values reach the robot today. The role is not the fault; the register class is.

How fast does the robot-to-PLC data refresh after the fix?

At the bus cycle rate configured for the connection, with both directions carried in the same cycle and no polling program on either side. That is also the diagnostic tell: a value that stays frozen while the robot program runs is a mapping or addressing fault, not a speed problem, so adding timers or read polling will not improve it. Fix the address or the mapped range instead.

Keep reading

  • How-to

    Control a PROFINET servo drive with cyclic telegram data

    No motion library is needed when a PLC only exchanges cyclic process data with a PROFINET servo drive: import the device description, attach the drive, select the same telegram the drive is configured for, and map the words. Standard telegram 1, PZD 2/2, is two 16-bit words each way — four bytes per direction — and the PLC logic sequences control word STW1 and reads status word ZSW1.

    Drives and motion

  • Troubleshooting

    Fix robot Profinet output writes over OPC UA

    Set the Profinet Internal Device Input Size and Output Size to 64 bytes each, under Controller tab, Configuration, I/O System, Profinet Internal Device, and robot output writes reach the PLC array. The failing direction, not the OPC UA status number, identifies the cause: a Bad-class write with the other direction working means the output byte image is missing.

    Industrial networks

  • Troubleshooting

    Troubleshooting S7-1200 PROFINET servo motion control issues

    Fix an S7-1200 PROFINET servo project in order: compile the motion calls in FB1 first, set drive and TIA Portal to the same telegram — Telegram 3 on this pairing — then prove one axis holds enable and velocity through repeated scans. A first-generation CPU 1214C executes independent single-axis motion only; the flying shear's deterministic master-slave cut belongs in the drives or in a motion-class controller, and no telegram adds it.

    Drives and motion