Troubleshooting
Why an HMI Writes Integers but Not B3 Bits Over DF1
Short answer
When an HMI writes T4, C5 and N7 data but B3 bits never change over DF1, the serial link is proven and the failure sits in the HMI software's binary-file translation. Check the engineering software version before baud, cable or PLC settings: a documented case was fixed by upgrading EBplus from 2.10 to 5.07.
On this page
- Why does my HMI write integers but not B3 bits over DF1?
- What does a working integer write prove about the DF1 link?
- How do I test the write at the PLC data table?
- Should I change the baud rate or the cable when only B3 fails?
- Is the PLC program overwriting the bit after the write?
- Am I writing the bit or the whole B3 word?
- How do I upgrade the HMI engineering software?
- How do I verify the B3 write is really fixed?
- Which fix does each test result point to?
- Questions asked
When an HMI writes T4 timer, C5 counter and N7 integer data to a MicroLogix over DF1 but B3 binary bits never move, the serial link is proven and the fault sits in the HMI engineering software's binary-file translation. Check the software version before the cable: on one documented HMI5070P installation, a project built with EBplus 2.10 wrote every file type except B3, and rebuilding it in 5.07 restored the binary writes with nothing else touched. The paired test below separates a driver defect from a dead link and from PLC logic that overwrites the bit; then come the upgrade steps and the verification.
Why does my HMI write integers but not B3 bits over DF1? #
Because the DF1 driver translates every data type through its own path, and one path can be broken while the rest work — in the documented case EBplus 2.10 failed only binary writes, and the 5.07 upgrade fixed them.
Over DF1, every HMI tag resolves to a controller data file: timers default to T4, counters to C5, integers to N7, binary data to B3. The cable, the RS-232 port, the full-duplex framing and the station addressing are shared by all of them. What is not shared is the translation the driver performs for each file type. For a binary tag, the driver has to assemble a request that names the file, the word and the bit inside the word, and send it as a bit-level write. The DF1 command set defines bit-level writes, so the protocol itself is not the limitation. A defect in that one translation path leaves the other file types writing normally and makes B3 look dead — a software signature, not a wiring signature.
What does a working integer write prove about the DF1 link? #
It proves the whole shared path works: the HMI transmitted a typed write request, the PLC accepted it, and the data table changed — so cable, baud, parity, station numbers and controller selection are all correct for write traffic.
A single N7 write that lands in the data table exercises every item on this list:
- the serial cable and its wiring, pin for pin
- the port's DF1 settings — baud, parity, framing, error checking
- full-duplex station addressing and the controller selection
- the driver's session handling and retries
- the controller's willingness to accept a write transaction
What an N7 write cannot test is the binary translation itself, and what the PLC program does to the bit afterwards. Those are the only two suspects left, which is why this symptom pattern points at software rather than wiring. If instead nothing at all reads or writes, in any data type and either direction, treat it as the link problem laid out in fixing RS-232 cable disconnected errors on a replacement HMI, and leave the driver question until data moves at all.
How do I test the write at the PLC data table? #
Open the programming software online, watch the target words in the data table, and command one controlled change to an N7 address and one to a B3 bit the PLC program never writes — the pattern you see names the fault.
Judge from the controller, never from the HMI screen: a screen value can update locally while no write ever leaves the panel. Run the paired test:
- Go online with the controller and open the data table on the word the HMI already writes, N7:10 for example.
- From the HMI, write a value you will recognize instantly, such as 1234, and confirm the table shows 1234.
- Pick a spare binary bit the program does not reference anywhere, B3:0/7 for example, and command it on from the HMI while watching the table.
- Read the result:
- N7 changes, B3 never moves — link proven, binary translation suspect; go to the software version.
- B3 changes and snaps back within a scan — a competing writer owns the bit; go to the logic check.
- Neither changes — stop treating this as a binary problem and troubleshoot the link.
- B3 changes correctly but the screen indication is wrong — the write works; fix the readback object separately.
The pairing changes exactly one variable between the two commands, the destination data type, across the same panel, cable, port, protocol configuration and controller.
Should I change the baud rate or the cable when only B3 fails? #
No — when T4, C5 and N7 writes repeat reliably, leave the serial configuration and cable exactly as they are; every one of those settings is proven by the working writes, and changing them destroys your known-good baseline.
Baud, parity, station number and cable swaps all attack the shared transport, and the shared transport is the one thing your working writes have already cleared. Every change there replaces a proven setting with an unknown one and leaves you two problems to debug instead of one. If your real symptom is that everything works but slowly — lagging screens, crawling values — that is transport health, closer to why an HMI freezes or updates slowly over serial than to a data-type defect, and still no reason to touch the B3 configuration. The serial settings change only when the paired test shows nothing at all moving.
Is the PLC program overwriting the bit after the write? #
If the bit changes and returns within one scan, yes: output logic, a force, or another device is writing the same address, and the HMI write is succeeding — a controller running a 10 ms scan erases it 10 ms later.
Cross-reference the failing bit in the controller project and hunt the other writers: output coils, move and copy instructions, first-scan initialization, sequencers, forces, and writes from any other station with access to the port. Then test with a bit that has exactly one writer, the HMI: command it on, watch the table, command it off. If it never moves, the request is not reaching that address and you are back on the translation branch. If it moves and snaps back, give the bit a single owner in the program — that is a logic fix, not a communications fix. While you work through the cross-reference results, keep the project's documentation intact: a selective descriptor import in RSLogix 500 brings comments in without overwriting the ones already saved.
Am I writing the bit or the whole B3 word? #
Check the object's write form before anything else on that one object: a bit command targets B3:0/7 alone, while a word command replaces all sixteen bits of B3:0 in one transaction — the wrong form makes a single object misbehave.
A bit command names file, word and bit, and the controller changes that one bit. A word command carries a 16-bit value and replaces the whole word at once. Mixed up, they produce exactly the one-object-fails pattern.
Worked example: bit n of a B3 word carries the weight 2^n, so bit 7 of B3:0 is 2^7 = 128, written 0000 0000 1000 0000. Suppose the object was left in word mode and writes decimal 1: it sets bit 0 (2^0 = 1) and writes 0 into the other fifteen bits, so bit 7 never moves and anything the program had latched in B3:0 is wiped. To command bits 0 and 7 together in word mode you would write 2^0 + 2^7 = 1 + 128 = 129. Decision: bit form for buttons and single commands; word writes only for packed command words the program deliberately unpacks. Then command the bit on and off and confirm the table reads 1 and 0.
How do I upgrade the HMI engineering software? #
Treat the upgrade as the resolving branch and as a controlled change: archive the working project first, install the fixed release, convert a copy, and redeploy only when the build is clean — then repeat the paired test before anyone uses the screen.
- Archive the untouched project and keep an installation of the old software that can still open it.
- Record the panel model, the serial port and its DF1 settings, the controller address and the list of failing B3 objects.
- Install the fixed release — 5.07 in the documented case, or the release the vendor currently distributes.
- Open a copy of the project and complete the conversion the new software asks for.
- Re-verify every binary tag: same file, word and bit, same bit-versus-word form, same write mode.
- Build the application and clear every error the build reports before you go near the panel.
- Download in an authorized machine state only — the new project can issue writes the moment it goes live.
- Repeat the paired test before the screen goes back into use.
How do I verify the B3 write is really fixed? #
Fix verified means the data table follows the HMI in both directions, the HMI follows the PLC, the T4, C5 and N7 objects that already worked still work, and the result survives a restart of the HMI application.
- Command the bit on and confirm 1 in the table; command it off and confirm 0. For momentary actions, watch both the press and the release transitions.
- Change the word from the controller side and confirm the HMI indication follows, which separates write transport from readback.
- Retest the T4, C5 and N7 objects that worked before, so the repair does not regress them.
- Restart the HMI application and its communications session, then repeat the bit test.
- Record the software version, project revision, tested addresses and results.
The repair is complete when repeatable binary writes survive a restart and nothing that worked before has stopped.
Which fix does each test result point to? #
Take the branch your paired test shows: N7 moves and B3 never does means upgrade the software; B3 moves and snaps back means fix bit ownership in logic; nothing moves means repair the link; one object only means fix that object's form and address.
- N7 changes, B3 dead across many objects: software-version branch, the documented precedent.
- B3 changes and snaps back within a scan: single-owner fix in the PLC program; leave the link alone.
- Nothing moves, either type: repair the link — cable, port settings, addressing.
- One object fails while its neighbors work: correct that object's address, data type and bit-versus-word form.
- The write lands but the indication is wrong: repair the readback object.
For the pattern this article is about — every file type but B3, on a link that demonstrably carries writes — the answer is the engineering software version, and the cable was never the problem.
Questions asked
Can I work around the failed binary writes with an N7 integer?
Yes, as a stopgap. The link already carries integer writes reliably, so park the command in a spare word such as N7:20 and unpack it in the PLC with bit-examine instructions on N7:20/0 through N7:20/15, which gives sixteen command bits per word. Change the HMI object, add the unpack rungs, and schedule the software upgrade that removes the workaround for good.
Are T4, C5, N7 and B3 file numbers fixed by DF1?
No. They are controller defaults, with timers at T4, counters at C5, integers at N7 and binary at B3, but a MicroLogix project can create B10 or N12 and use those instead. DF1 addresses whatever file number the data table actually defines, so confirm the number in the controller before blaming the driver. A tag pointed at a file that does not exist fails for every data type, not just binary.
How long does the HMI write last if PLC logic writes the bit back?
One scan. The HMI write lands between scans, the logic's output instruction sets the opposite state on the next rung execution, and the bit reads changed for about 10 ms on a controller running a 10 ms scan. An HMI polling every few hundred milliseconds will almost never catch the flicker, which is why you watch the data table in the programming software instead of the screen.
What if B3 writes still fail after the software upgrade?
Then it is not the old translation defect. Re-run the paired test with a single-writer diagnostic bit, confirm the object's address and its bit-versus-word form, and clear forces and any competing logic. If the data table still never moves while N7 does, record the software version, the panel model and the failing addresses, and raise it with the software vendor's support, because a binary-write failure that survives the current release is theirs to reproduce.
Does the upgrade change anything on the PLC side?
No. The repair lives entirely in the HMI engineering software: the controller program, its channel configuration and the cable stay untouched, so your change control and your risk sit on the panel half of the system. Only the HMI project gets rebuilt, which is why the archive-and-retest discipline matters more here than anything you would do in the PLC software.