Configuring P3000 Modbus TCP Polling of CLICK PLC Slaves

A Productivity P3000 acting as master over several CLICK PLCs on Ethernet is a Modbus TCP polling system. The P3000 reads and writes each CLICK in turn, and that polling model drives both the setup and the most common field complaint: momentary inputs that never reach the master. Get the I/O moving first. Then fix the timing properly.

1. Use MRX/MWX instead of RX/WX

The usual first attempt is to drop RX/WX into the P3000 ladder and point it at a CLICK. That fails. RX and WX work only between Productivity CPUs, for example P3000 to P1000 or P2000. They depend on the remote CPU publishing its tag database. A CLICK has no tag database, so there is nothing for them to connect to.

Use the Modbus instructions instead:

• MRX: Modbus read. It runs either Modbus RTU over serial or Modbus TCP over Ethernet.
• MWX: Modbus write, with the same transport options.

For plain remote I/O, where the master reads the CLICK discrete inputs and writes its output coils directly, the CLICK needs no ladder program. Section 7 covers the case where you will need one anyway.

Check: In the P3000 project, every instruction that addresses a CLICK is MRX or MWX with the TCP transport selected. None of them is RX/WX.

2. Give every CLICK its own static IP

Modbus TCP identifies each slave by its IP address. The master opens a TCP connection to each slave on the standard Modbus TCP port 502. Two CLICKs with the same IP will fight on the wire. Symptoms are intermittent timeouts, or data that seems to come from the wrong cabinet.

1. In the CLICK programming software, set a static IP, subnet mask and gateway for each CLICK. Put every node on the same subnet as the P3000 Ethernet port you will poll from.
2. Write a node table: node name, cabinet location, IP address, and what I/O it carries.
3. Download the configuration to each CLICK and power-cycle it so the new network settings take effect.
4. Label the IP on the CLICK or the panel door. The next person on shift will need it.

Check: From a laptop on the same switch, ping every CLICK IP. Unplug one CLICK and confirm that only its IP stops answering. Stop here if any address answers from two places. Clear the duplicate before touching ladder logic.

3. Build the address map from the CLICK Address Picker

This is where multi-CLICK systems get confusing fast. Every CLICK exposes the same Modbus address map. The first discrete input on node 1 has exactly the same Modbus address as the first discrete input on node 2. Only the IP address in the instruction tells them apart.

The CLICK Modbus addresses are fixed. You don't configure them, you look them up:

1. Open the CLICK programming software.
2. Open the Address Picker.
3. Select Display Modbus Address. The picker now lists the Modbus address beside each CLICK memory location.
4. Record the starting address and point count for each block you need: X discrete inputs, DF registers carrying analog values, and the output coils.

Use the Address Picker to identify the Modbus object type for each block, then match the function code in the P3000 instruction to it. The standard Modbus mapping is:

Modbus object	Read function	Write function	Typical CLICK use in this system	P3000 instruction
Coils (bit, read/write)	01	05 single / 15 multiple	Output coils	MWX (write), MRX for readback
Discrete inputs (bit, read-only)	02	n/a	X inputs, per the Address Picker listing	MRX
Holding registers (16-bit, read/write)	03	06 single / 16 multiple	DF values (two registers per 32-bit float)	MRX
Input registers (16-bit, read-only)	04	n/a	Only if the picker lists the data there	MRX

A DF value is a 32-bit float. It spans two consecutive 16-bit Modbus registers. Set the read count to twice the number of DF values. Plan on checking word order during commissioning (section 4).

On the P3000 side, prefix every destination tag with the node name from your node table. When node 2's third input comes on, the tag name should say so. Don't make the next person work it out from a Modbus offset.

Check: The map is filled in for every node: IP, object type, function code, start address, count, and P3000 destination tags. No two nodes share a destination tag.

4. Configure the MRX reads, one node at a time

Each CLICK carrying both digital and analog inputs needs two reads: one MRX for the X discrete input block and one for the DF analog block. Read contiguous blocks, not single points. Every MRX is a separate request and response on the network. Fewer, larger reads shorten the polling cycle you will measure in section 6.

1. Add an MRX and select Modbus TCP.
2. Enter the node 1 IP address from the node table.
3. Select the function code that matches the X input block's object type.
4. Enter the start address and point count from the Address Picker.
5. Point the destination at the node-prefixed P3000 tags or array.
6. Add a second MRX for the DF block. Use the holding-register function, twice the DF count as the register count, and a float destination.
7. Get node 1 fully working before copying the pair for node 2. Change only the IP and the destination tags. The Modbus addresses stay identical.

The float word-order trap: if the DF value arrives at the P3000 as a very large, very small, or nonsense number, the two 16-bit words are swapped. Open the MRX setup and adjust its word/byte ordering options. Compare against a value you know: write a fixed DF value in the CLICK, such as a round number, and read it back.

Check: Energize one X input on node 1. Only the node 1 tag changes in the P3000 Data View. Apply a known analog signal to a node 1 channel. The DF value in the CLICK and in the P3000 agree. Repeat for each node. Stop here if any node's data lands in another node's tags. The IP or destination tag in that instruction is wrong.

5. Configure the MWX coil writes and decide the fail state

Each CLICK needs one MWX that writes its output coil block from the P3000 tags. Outputs are the forgiving side of this system. Output state is held, so polling delay only postpones a change and never loses it.

1. Add an MWX with Modbus TCP and the node IP.
2. Select the multiple-coil write function. Use the output coil start address and count from the Address Picker.
3. Point the source at the node-prefixed output tags.
4. Repeat per node.

A Modbus slave does not clear its coils when the master goes quiet. With no CLICK program, a pulled cable or a stopped P3000 leaves every CLICK output in its last written state. For any output that moves product or machinery, that is not acceptable. The fix needs CLICK logic:

1. Have the P3000 toggle or increment a heartbeat register in each CLICK on every write cycle.
2. In the CLICK, run a timer that resets on every heartbeat change.
3. If the timer expires, force the outputs to their safe state.

Check: Toggle each output tag in the P3000 Data View and confirm the matching CLICK output follows. Then unplug the node's Ethernet cable while an output is on. Record what the output does. If it stays on and must not, add the heartbeat watchdog before going further.

6. Sequence the polls instead of speeding up the trigger

Two CLICKs with digital inputs, analog inputs and outputs means six instructions in the comms rotation: two MRX and one MWX per node. A common way to rotate through them is a cyclic counter that pulses each instruction in turn.

The wrong fix appears as soon as pushbutton presses start going missing: shorten the cyclic pulse. In one two-CLICK system, the trigger was pushed down to 2 ms, which is far faster than a Modbus TCP transaction can complete. Presses still disappeared inside a roughly 10 ms scan window. Here is why:

• Each node's input block is sampled once per revisit period, T_revisit.
• T_revisit is set by how long each transaction takes to complete (request, CLICK response, network), summed over every instruction in the rotation. It is not set by how often you fire the trigger.
• An input that turns on and back off between two reads of its block is never seen. The CLICK registered the press correctly. The master simply wasn't looking at that moment.
• Firing instructions faster than they complete doesn't shorten T_revisit. It only queues requests or produces errors.

The detection rule, derived from sampling: a raw input is guaranteed to be seen only if its on-time exceeds T_revisit plus the CLICK scan time. Every node you add lengthens T_revisit for all nodes.

Chain the instructions on completion rather than on a fixed-rate pulse:

1. Enable instruction 1.
2. When its status reports success or error, advance a step counter and enable instruction 2.
3. After the last instruction, return to 1.
4. On error, log it, count it per node and move on. One dead node must not stall the whole rotation.

Check: Put a counter on the success status of node 1's X input MRX. Reads per second gives T_revisit = 1 / rate. Record T_revisit for each node. You need that number in the next section.

7. Trap short inputs inside the CLICK

Stop here if the plan was "no CLICK program at all" and the system has pushbuttons, sequence entry, or sensors that give a quick off-on-off pulse. Toggle and maintained switches are fine with raw polling. Momentary signals are not, and they need logic in the CLICK.

Option A: pulse stretching with an off-delay timer. Hold the reported bit on for a fixed time after the physical input drops. A 20 ms off-delay on the CLICK inputs cured missed presses against a roughly 10 ms polling window.

Choose the off-delay from your measured T_revisit, not from someone else's number. Set it above the worst-case T_revisit for that node, with margin.

// CLICK logic, one rung per momentary input (placeholder names)
// Physical input  --[off-delay timer, preset > T_revisit]--> stretched bit
// P3000 MRX reads the stretched-bit block, not the raw X block
IF input_raw THEN stretched := TRUE; reset off_delay
IF NOT input_raw AND off_delay.done THEN stretched := FALSE

Option B: latch and acknowledge. Use this when every press must count, for example a button sequence typed like a phone number.

1. The CLICK latches an internal bit on the rising edge of the input.
2. The P3000 reads the latched bit, acts on it, and writes an acknowledge coil back.
3. The CLICK clears the latch when it sees the acknowledge.

This captures a press regardless of polling speed. For fast repeated presses, count edges in a CLICK register and read the count instead.

Either option changes the address map. Point the input MRX at the block holding the stretched or latched bits instead of the raw X block, and update the node table.

Check: Tap each momentary input as fast as you can, 50 times. The P3000 must register 50 events, confirmed with a rising-edge counter on the P3000 tag. For Option B, confirm that the latch clears only after the P3000 acknowledge.

8. Lock a monitoring layout in Productivity Suite

Commissioning goes faster when you can watch every node's inputs, outputs and comm counters on one screen. The Data View, Tag Database and bit histogram are floating windows. Stack them next to the ladder, or put them on a second monitor.

1. Click the padlock icon on the top toolbar to unlock the layout.
2. Open the Data View and the Tag Database.
3. Drag one window on top of the other. Release only when the drop outline expands to the full width and height of the window underneath. That gives a tabbed window.
4. If they split horizontally or vertically instead, pull one window completely off and drag it back in.
5. Click the padlock again to lock the layout. It is saved between sessions.

Avoid Tools > Reset Screen Layout as a quick fix for windows stranded off-screen. It throws away the whole arrangement. Windows usually get stranded when the software was last closed with them on a second monitor that is no longer connected. Try closing and restarting Productivity Suite first, then a PC reboot. Before leaving a dual-monitor desk, move the windows back to the laptop display and close the software.

Check: One Data View shows, for every node: input tags, output tags, the success counter from section 6, and an error counter.

9. Choose a different remote I/O architecture when the node count grows

CLICKs as Modbus slaves are cheap, easy and modular, which suits equipment that gets rearranged. The costs are manual addressing, identical address maps on every node, and pulse capture that needs slave logic. If the hardware isn't bought yet, compare the alternatives:

Option	How data moves	Slave code needed	Tradeoffs
CLICK via MRX/MWX	Modbus TCP, fixed address map per node	None for plain I/O. Yes for pulse trapping and watchdog.	Lowest CPU cost. Addressing gets confusing with many nodes. Momentary inputs can be missed.
P1000 via RX/WX	Tags named in the P1000 and imported into the P3000 in both directions	Tag naming in the P1000	Remote tags appear in the P3000 tag database like local I/O. Remote inputs have shown faster response than CLICK polling. The CPU costs more than a base CLICK. Analog modules are comparable or cheaper. Check the current module catalog for input density: 15/16-point input cards were once missing.
ProNet	Data exchanged through arrays between Productivity CPUs	Array handling	More data volume and flexibility. More setup work than RX/WX because data must be moved into arrays.
EtherNet/IP remote I/O	Productivity CPU as scanner to third-party adapters, for example Opto22 SNAP I/O used with a P2000	None, no ladder in the remote	Good for harsh locations. PxK hardware isn't suited to cold enclosures: a rooftop condenser cabinet at -10 °F (about -23 °C) was one example. Check the operating temperature ratings in each datasheet.
Productivity remote racks / CPoE	Native remote I/O, for example racks with a P2-RS head	None	Setup is straightforward and runs alongside networked GS drives on a P3000. Remote rack hardware is expensive.

Check: Confirm the choice against three numbers: total node count, the shortest input pulse the process produces, and the coldest and hottest enclosure temperature. If the shortest pulse is below the T_revisit you measured in section 6 and you won't add CLICK logic, move off Modbus polling.

10. Run the end-to-end verification

1. Power-cycle the P3000 and every CLICK together. All nodes resume communicating with no manual intervention, and error counters stop climbing.
2. Walk every input on every node. Each one changes only its own node-prefixed tag.
3. Walk every output from the Data View. Each CLICK output follows, and no other node's output changes.
4. Inject a known analog value on each channel. The CLICK DF value and the P3000 value agree, with correct word order.
5. Repeat the 50-tap test on every momentary input.
6. Pull each node's Ethernet cable in turn. The rotation keeps serving the other nodes, the error counter for the pulled node rises, and that node's outputs go to the fail state you chose in section 5.
7. Record T_revisit, off-delay presets, IPs and the address map in the panel documentation.

FAQ