Troubleshooting
Why a Micro850 will not read tags over a DF1 I/O server
Short answer
A Micro850 serves variables through a Modbus map you build in Connected Components Workbench, not through DF1 or ABLOGIX I/O servers, because its memory has no data-table files for those drivers to read. Map each variable, poll the mapped range with an independent Modbus client on unit identifier 1, and set the tag address to the offset that actually answers.
On this page
- Why will a DF1 or ABLOGIX I/O server not read Micro850 tags?
- Does the Micro850 serial port support DF1 at all?
- How do you map Micro850 variables so a client can read them?
- Why does the Modbus topic connect but return no tag values?
- What unit identifier should the Modbus TCP topic use?
- Should you add 1 to the mapped Modbus address?
- How do you prove which coil answers before editing every tag?
- Can you do remote assistance through the DF1 port?
- What do you change first, in what order?
- Questions asked
A Micro850 hands its variables to another system only through a Modbus map built in Connected Components Workbench (CCW); a DF1 or ABLOGIX I/O server cannot read them, because the controller has no SLC-style data-table files for those drivers to address. When the Modbus topic connects but no tag values come back, the cause is almost always the topic's unit identifier or a one-object address mismatch, and an independent Modbus client proves which in ten minutes. Below: why DF1 fails, how to build the map, and the order to fix a dead topic.
Why will a DF1 or ABLOGIX I/O server not read Micro850 tags? #
It fails because a DF1 or ABLOGIX I/O server reads numbered data-table files such as N7:0, B3:1 and F8:2, and the Micro850 memory model has none: its variables are named, and the access path built for them is a Modbus map polled as Modbus objects.
Those numbered files exist on PLC-5, SLC 500 and MicroLogix controllers, which is exactly the population DF1 drivers were written for. The Micro800 generation replaced files with named variables, so the driver has no file number to request and nothing comes back that a tag can be built from. The integration paths Rockwell Automation documents for this family all go through Modbus mapping: the Modbus Mapping page exists to serve Modbus devices such as PanelView Component terminals, and the documented OPC data-access route to a Micro850 on Ethernet is Modbus/TCP as well.
DF1 behaves differently even among the older controllers themselves, as covered in why DF1 reads work on an SLC 500 but not a PLC-5, but no member of that set reaches a Micro800 variable. If your client speaks CIP instead of Modbus, that is separate territory covered in why Micro850 explicit writes fail to SMC EX600 outputs.
Decision: retire the DF1 or ABLOGIX topic for this controller and spend the hour on the Modbus map.
Does the Micro850 serial port support DF1 at all? #
Yes, the port itself lists DF1 protocol modes, so the protocol can be present without giving an I/O server anything to read; DF1 support on the port and variable access through DF1 are two different things.
The Micro800 family selection guide lists additional DF1 protocol modes for Micro850 controllers, alongside the embedded USB programming port and an RS-232/RS-485 serial port, and DF1 tools that speak full-duplex and half-duplex to PLC-5, SLC 500, MicroLogix and Micro800 serial ports do exist. That is line-level protocol support, not a variable service: the port can carry DF1 frames while the controller still exposes no data tables to them. The serial port's other configured role is Modbus RTU, set in the port configuration in CCW.
Decision: keep the data path on Ethernet with Modbus TCP; the serial port buys you nothing for tag access.
How do you map Micro850 variables so a client can read them? #
Open the Modbus Mapping configuration in Connected Components Workbench, add one row per variable, and assign each variable an address; the table accepts a maximum of 200 entries, so plan the address range before you fill it.
- Open the controller project in CCW and find the Modbus Mapping configuration page.
- Add one entry per variable the gateway needs: choose the object space (coil, discrete input, input register or holding register), the starting address, and the variable.
- Write the map down as you build it - variable, object space, address - because the gateway tag must point at exactly that address.
- Download the project to the controller; an entry that exists only in the open project serves nothing.
- Point the gateway's Modbus topic at the controller: IP address, TCP port 502, unit identifier 1.
- Define the gateway tag with the Modbus server name, the topic, and the mapped address.
- Test one mapped object at a time before wiring the rest of the database.
The 200-entry maximum is documented in Rockwell Automation's support answer on Micro800 Modbus mapping limits. One caution before step 6: a mapped object is as writable as its object space allows, so keep machine-stop logic in the controller and apply the practices in safe Modbus writes to PLC output registers from SCADA to anything the gateway can command.
Decision: one row per variable, one written map sheet, one download, then tags.
Why does the Modbus topic connect but return no tag values? #
The topic connects at the TCP level and still returns nothing when one of three things is wrong: the variable is not actually mapped in the controller, the topic's device identifier is 0 instead of the identifier the server answers, or the tag address points one object away from the mapped one.
One reported configuration with this exact symptom: controller at 192.168.2.107, Modbus topic with device ID 0, digital input 1 mapped as coil 1, gateway tag at address 1 on that topic, and no values after saving. Those numbers belong to that installation; they are diagnosis inputs, not Micro850 defaults.
A Modbus TCP server accepts the connection on port 502 before it looks at the unit identifier or the address, so a green connection proves routing and the port, nothing more. The failures that hide behind it:
- The map is not in the controller - the entry exists in the CCW project but the corrected project was never downloaded.
- The unit identifier is wrong - the request arrives and the server does not act on it.
- The address reference is off by one object - the request is served at an offset where nothing is mapped, so the tag reads a permanent zero.
Decision: count a tag as working only when a value returns and tracks the physical input.
What unit identifier should the Modbus TCP topic use? #
Start with unit identifier 1: identifier 0 is reserved in Modbus TCP for traffic a gateway forwards to a serial slave, so it is the wrong value for a direct Ethernet poll, and 255 is the other identifier a directly addressed device uses.
The reported topic carried device ID 0, which makes it the first suspect in that failure. Identifier confusion is not an Ethernet-only fault - why Modbus RTU sends to slave address 0 instead of your device covers the same mistake one level down on serial links.
Decision: set the topic to unit identifier 1; if the socket opens and 1 returns nothing, poll 255 once before you suspect the map.
Should you add 1 to the mapped Modbus address? #
Do not apply a blanket offset: the add-one rule comes from a Schneider controller where a mapped address of 0 answered at poll address 1, and that is a reference-base difference to test on your Micro850, not a property of it.
Modbus protocol offsets start at 0, while most published tables and many client address fields start at 1, so "coil 1" in a table and "offset 0" on the wire are the same point, and a client field labeled address can mean either base. The Schneider observation is that difference seen from the client side: its poll of 1 meant offset 0, where the map lived.
Decision: no blanket add-one on this controller - run the scan below and set each tag to the offset that answers.
How do you prove which coil answers before editing every tag? #
Scan before you edit: read ten coils from offset 0 with an independent Modbus TCP client on unit identifier 1, toggle the physical input, and the bit that moves tells you the offset the controller actually serves - no guessing.
Put a laptop on the same switch and poll 192.168.2.107 on port 502, unit identifier 1, function code 01 (read coils), start offset 0, quantity 10. Ten coils return ceil(10 / 8) = 2 bytes. Toggle the physical digital input and watch the first byte:
- It flips 0x00 to 0x01 (binary 00000001, bit weight 2^0 = 1): the coil lives at offset 0. If the gateway treats its address field as a 0-based offset, the tag at address 1 was polling offset 1, one coil past the map, reading a permanent zero. Set the tag to address 0, or move the map entry to address 1 - pick one convention and write it on the map sheet.
- It flips 0x00 to 0x02 (binary 00000010, bit weight 2^1 = 2): the coil lives at offset 1 and the tag address matched all along, so the original no-data symptom was the unit identifier, which you have already corrected.
A laptop with any Modbus TCP client does the job; if you would rather script the poll, the client configuration in setting up a CODESYS Modbus TCP client to talk through a gateway is a working example.
Decision: the moving bit defines the address, and the tags follow the scan, not a rule borrowed from another brand.
Can you do remote assistance through the DF1 port? #
Route remote assistance over Ethernet with Connected Components Workbench, not through the DF1 port: the programming connections the Micro850 documents are its embedded USB port and its Ethernet path, and the working remote-programming report on this family used a Micro820 behind a Modbus TCP gateway.
Data access and remote programming are separate functions. That Micro820 report is evidence for the Micro820 route, not for the Micro850's DF1 port, so do not transfer it. The controller in the failed setup is already on Ethernet, which is where CCW connects for programming.
Decision: run remote assistance over the Ethernet path with CCW, and treat the DF1 port as a serial link, not a remote door.
What do you change first, in what order? #
Fix it in this order: drop the DF1 topic, build the Modbus map within its 200-entry limit, set the topic to unit identifier 1 on port 502, scan the mapped range, and only then rebuild the gateway tags to the offsets that answered.
- Drop the DF1 or ABLOGIX topic for the Micro850; keep it for any SLC 500 or MicroLogix still on the panel.
- Build the Modbus map in CCW, within the 200-entry limit, and download the project.
- Point the topic at the controller on port 502 with unit identifier 1, trying 255 once if 1 stays silent.
- Scan the mapped coil and register ranges with an independent client, toggling inputs to identify live offsets.
- Rebuild the gateway tags to the offsets that answered, one object at a time.
By the last step every tag points at an offset the scan has already proven, and the DF1 question is closed.
Questions asked
How do you read more than 200 points when the Modbus mapping table is full?
Pack the discrete states. Combine 16 booleans into one INT in the ladder program, map that INT to a single holding-register entry, and unpack the bits on the client side. The same 200-entry limit then covers 200 x 16 = 3,200 discrete points, while each analog value keeps one entry of its own.
Why does the connection show healthy when no tag values return?
Because a Modbus TCP server accepts the socket on port 502 before it validates anything. A refused connection points at routing; an open connection with a timeout points at the unit identifier; exception code 02, illegal data address, in the response means the map has no entry at the offset you polled. Read the client's response status, not its connection lamp.
How do 40001-style register references convert to Modbus offsets?
Published tables use 1-based references while the protocol uses 0-based offsets: coil 00001 and discrete input 10001 both start at offset 0 in their spaces, and input register 30001 and holding register 40001 also start at offset 0. A tag written as 40001 and a client configured for offset 0 are therefore the same point, and that reference-base mismatch is what the add-one rule is really about.
Can the gateway keep serving DF1 to the MicroLogix on the same panel?
Yes. An I/O server platform runs the DF1 or ABLOGIX server for an SLC 500 or MicroLogix and a Modbus server for the Micro850 side by side, and each remote tag simply names its own server and topic. Nothing about the Micro850 limitation forces you off DF1 where that protocol still fits the older controllers.