Troubleshooting
Why explicit and implicit EtherNet/IP messaging do not interwork
Short answer
Explicit messaging is request/response CIP over TCP between a client and a server; implicit messaging is a scheduled I/O connection between a scanner and an adapter. The four roles are implemented and configured independently, so one endpoint can lack exactly the mode the other needs, and a reachable IP address proves nothing. Match each endpoint's documented roles, assemblies and byte lengths before you blame the network.
On this page
EtherNet/IP runs two different conversations, not one. Explicit messaging is a request/response exchange over TCP, triggered by your program, between a client and a server. Implicit messaging is a scheduled I/O connection between a scanner (the originator) and an adapter (the target), exchanging a fixed byte layout at a configured interval. The four roles are separate capabilities, configured independently, and the failure that costs you a day is one endpoint offering exactly the mode the other cannot perform. A reachable IP address proves none of this. Work the checks below in order; each one separates a network fault from a role mismatch.
Two CIP models, four roles #
CIP is the application protocol ODVA publishes for EtherNet/IP; DeviceNet carries the same object, instance and service model on a different wire, which is why the vocabulary looks familiar across both. CIP defines two connection types, and every device implements only the subset its vendor built and documented.
Explicit messaging is a request/response exchange, unicast over TCP. Each message carries its own addressing — source, destination, service and object path — so the receiver is told what to do with every fragment of data. Your application triggers each transfer and reacts to its completion; nothing moves on its own. The initiating device is the client, the answering device is the server.
Implicit messaging is one persistent I/O connection. The scanner, also called the originator, opens it from a connection definition; the adapter, also called the target, then produces and consumes fixed byte layouts called assemblies on a schedule set by the requested packet interval. The data carries no per-message addressing: position in the assembly is the only meaning it has. I/O traffic rides UDP.
The word to hold on to is independently. A device can be a server with no I/O assemblies, an adapter with no server, a client that cannot scan, or any other corner of that matrix. The EtherNet/IP label on two nameplates names a protocol family; it is not a compatibility statement.
What each mode cannot do #
An explicit client cannot consume an I/O assembly. There is no scheduled layout to subscribe to; data moves only when a request triggers it, so an HMI driver built for explicit reads will never see a cyclic assembly no matter how the target is configured.
Two servers exchange nothing. Both sit waiting for requests; neither originates. If both of your devices present server roles, one of them needs a different role in firmware, a different configuration, or a different job in the architecture.
A scanner cannot force I/O onto a device without a documented connection definition. Correct IP addressing cannot fix the wrong assembly instance or the wrong byte count; the target refuses the connection or the fields land misaligned.
Commanding motion adds a fourth constraint: a drive's motion interface is typically documented against specific controller capabilities, and reading a parameter explicitly is not that interface.
Whatever rides this link, drive enables and motion commands on standard I/O are not a safety function; the stop category that protects people belongs on the safety-rated channel that the machine's risk assessment called for.
The diagnostic list #
Run these in order; each reading moves you one layer closer to the guilty endpoint.
- Confirm the physical link at both ends and the intervening switch ports: link indications, error counters, speed and duplex. An absent link sends you back to cable, connector or port configuration.
- Record both endpoints' IP address, subnet mask and gateway. Check for duplicate addresses and, across a routed boundary, the return path as well as the outgoing one.
- Capture at a point that sees the requesting device and trigger the real application operation, not a connectivity test. A ping that succeeds has proved IP reachability and nothing else.
- If the request leaves the sender but never arrives, the fault is the forwarding path: addressing, switching, routing or filtering.
- If an error response comes back, decode it before touching anything else. A CIP error response is the narrowest diagnostic you will get: it proves the request reached an application service and names the refused object, instance, service or connection. For a worked case of an explicit write failing at the object level, read why explicit writes to Omron assemblies fail over EtherNet/IP.
- If the request arrives and nothing returns, the receiver's role or service is the suspect: service disabled, wrong request format, or a role the device does not implement at all.
- For an implicit link, compare the connection definition field by field against the target's documentation: input assembly instance, output assembly instance, both byte lengths, whether a configuration assembly is required, and the requested packet interval.
- For a scanner-adapter link that opens and then drops, suspect the connection parameters rather than the cable; the timing and assembly settings decide it, as in fix EtherNet/IP I/O between a ctrlX adapter and a Rockwell scanner.
Read the pairing before you configure #
A five-minute documentation read predicts the outcome before any of the above. For each endpoint, find the statement of the roles and the table of objects or connection definitions, then fill in this matrix:
| Exchange you need | Initiating endpoint must be | Receiving endpoint must be | Where it is written |
|---|---|---|---|
| Parameter or diagnostic access | Explicit client | Server supporting that object and service | Object and service list in the communication manual, plus the EDS |
| Cyclic I/O exchange | Scanner (originator) | Adapter (target) with matching assemblies | Connection definition in the manual and EDS |
| Servo motion commands | Controller meeting the drive's documented motion interface | Drive supporting that interface | Drive's controller compatibility documentation |
If any cell in the second or third column is blank in the documentation, no configuration fills it. That blank is your answer, and you got it before touching the network.
Sizing the assemblies for a 10-word read and 10-word write link #
Take the volume from your own working Modbus TCP link — 10 words read, 10 words written — and check what it takes to move the same data as an implicit EtherNet/IP connection. The example is illustrative; the arithmetic is the part that generalizes.
Inputs:
- Words read from the target: 10 words (your link's stated read volume).
- Words written to the target: 10 words (the same link's write volume).
- Register width: 16 bits per word, so 2 bytes per word on both sides.
- Container: the CIP Assembly object, class code 04 hex, whose instances hold the process data sent and received by the application.
Rule in words: an implicit connection moves exactly the bytes of its configured assemblies, every cycle, in both directions, and the originator's configured input and output lengths must equal the target's documented assembly lengths byte for byte.
Arithmetic:
- Input assembly (target to originator): 10 words × 2 bytes/word = 20 bytes.
- Output assembly (originator to target): 10 words × 2 bytes/word = 20 bytes.
- Total payload per cycle: 20 bytes + 20 bytes = 40 bytes.
Result: configure the originator for a 20-byte input assembly and a 20-byte output assembly, with the instance numbers copied exactly from the target's connection definition.
The traffic is trivial — 40 bytes per cycle is far below any practical limit — so bandwidth is never the question; agreement is. The threshold is byte for byte: one word of difference, 22 bytes against 20, and the target rejects the connection or every field shifts. If either device's documentation does not show an I/O role with assemblies of exactly these lengths, this data does not ride implicit between these two endpoints — poll it explicitly in 10-word reads and writes, or put a converter between them.
Where the EDS file fits #
An EDS file is the device's electronic data sheet: it states the CIP identity, the connection choices and the assemblies, and the scanner's configuration tool reads it so you do not guess instance numbers and lengths by hand. With the correct EDS, an EtherNet/IP integration is quick; with the wrong or missing one, you are guessing exactly the fields that reject connections. What an EDS cannot do is add a capability the device never had — why an EDS file will not add EtherNet/IP to a terminal server shows that limit at its clearest.
The decision for each case #
With the role matrix in front of you, the decision is mechanical:
- Both devices do explicit and one lacks implicit: make the side with the better driver the client and poll. An HMI polling a barcode scanner or drive for status and parameters is the normal design, on whatever interval the process tolerates.
- The application needs cyclic I/O or motion and one endpoint cannot take the role: no setting fixes that. Insert a device that owns both sides, such as an industrial mini PC in the cabinet running protocol conversion that terminates the I/O connection on one side and polls the server on the other.
- Both do implicit but the assemblies disagree: align your instance numbers and byte counts to the target's documentation, because the target's definition is fixed and yours is not.
- The drive documents its motion interface against a specific controller class: command it from a controller that meets the documentation, and leave the HMI on explicit status.
Two endpoints that agree on roles, objects and byte counts connect in minutes; the pair that disagrees on any one of them never connects, and no amount of network work changes that.
Questions asked
Does a successful ping between the two devices prove EtherNet/IP will work?
No. A ping is an IP-layer echo; it proves the network path and addressing, not the application. Two devices can pass ping all day while one waits for explicit requests the other never sends, or expects an I/O connection the other cannot originate. Prove the CIP conversation separately: trigger the actual application exchange and confirm the request, the response and any error codes.
Can one device support both explicit and implicit messaging?
Yes, and many do. A typical adapter implements a server for explicit parameter access plus I/O assemblies for a scanner, while a PLC commonly acts as client, server and scanner at once. But each role is a separate documented capability and each connection a separate configuration, so read the device's own communication manual and EDS rather than assuming the pair from the EtherNet/IP label.
Do explicit and implicit messages use different transports?
Explicit messaging is request/response unicast over TCP, opened per transaction or reused as a standing message connection. Implicit I/O runs as a persistent scheduled connection over UDP, so the update rate comes from the connection configuration, not from your program logic. This matters for diagnostics: explicit traffic is visible as readable request and response pairs, while a lost I/O connection shows up as connection timeouts rather than retries.
Why does the same 10-word exchange take minutes on Modbus TCP and hours on EtherNet/IP?
Modbus TCP offers one model: a client reads and writes numbered registers, and nothing else has to agree. EtherNet/IP adds a second model and four roles, then requires a per-connection definition with assembly instances, byte lengths, a possible configuration assembly and a packet interval. Every one of those is a place a pairing can mismatch, which is why the protocol name alone never settles compatibility.
What is the Assembly object and why do instance numbers matter?
It is CIP object class 04 hex, the standard container whose instances define the produced and consumed I/O byte layouts. The instance number selects which layout a connection uses, and the instance's length defines how many bytes move each cycle. A wrong instance or a wrong length is the most common reason a healthy network still refuses an I/O connection.