SLC to CompactLogix tag mapping for HMI screens

Why the panel's addresses stop resolving

An SLC-style controller stores data in numbered files: N7 holds integer words, B3 holds bits, and a panel address such as N7:52 points at word 52 of file N7. A CompactLogix controller stores named tags instead, so the same request finds nothing and the object shows an error or a bad value.

You do not have to change how the panel addresses data. You need an array in the controller that answers under the old name. The pattern is documented in the SLC 500 conversion reference manual, publication 1756-RM085: the SLC address N7:500 maps to the Logix array element N7[500]. The SLC-to-CompactLogix migration application note, publication 5069-AP001, covers the tooling: the RSLogix Project Migrator it describes converts SLC 500 data table files into Logix arrays automatically. Get both documents from the manufacturer's literature library before you start.

What you need

• The last archived SLC 500 project file for the ML1500. The conversion tools read the data table out of it, so find it before the old controller leaves the building.
• The RSLogix 5000 project for the L32E, with its I/O configured, even if the logic is still a shell.
• The panel programming software, its cable, and a backup of the current application.
• A written cross-reference for the panel tags: SLC address, meaning, and read or write direction for each object.
• One scratch word the panel may write to during tests, such as N7:200 if nothing in the logic uses it.
• A protocol check before the swap. Confirm which driver and connection the panel uses today; the protocol check for replacing a legacy HMI applies here too.

Check the import path first

Panel makers publish application notes on tag import, and many panel software versions can build a tag list from a file or from the controller's tag database. Whether it works depends on the software version in service, so find the note that matches your version before you edit anything.

If an import is documented for your version, run it on a copy of the panel project. The import fills the tag list; it leaves the screen objects pointing at their old entries, so every verification step below still applies. If no import exists for your version, the controller-side map is the documented alternative and needs no new panel software.

The order of work is the same as when you import a PLC tag file into an HMI project: import, inspect the result, then verify screen by screen.

Map the SLC data files in the Logix project

RSLogix 5000 has a built-in function that maps SLC-style addresses to Logix tags, and the panel driver has a matching SLC/PLC mapping option on its side. Three decisions make the map:

1. Names. Keep the old file names. An array named N7 answers a request for N7:52 at element 52, because register numbers and array indexes both start at zero and the element number equals the register number.
2. Type. Keep integer files as 16-bit INT arrays. An SLC integer word is 16 bits, and the panel driver expects a 16-bit register per address.
3. Size. Cover the highest address in use, plus one element for the zero offset. Running the migrator on the SLC 500 project creates the arrays at the old file sizes for you.

On the panel side, the documented first step of the SLC/PLC mapping option is matching the communication parameters: the old serial node settings become the new controller's IP address and route. Set both sides before the first test.

Example: N7 mapping for a ten-screen panel

Scenario: an ML1500 drives ten HMI screens over an SLC-style connection, and a CompactLogix L32E replaces it. N7 sits at its SLC default size of 256 words, so addresses run from N7:0 to N7:255, and B3 is at its 256-word default too. A survey of the ten screens finds 96 distinct N7 words in use, with the highest address at N7:147.

Sizing: 147 plus 1 is 148, so 148 elements would cover every address the screens use. Keep all 256 elements anyway. The array then matches the old file one for one, and words N7:148 through N7:255 stay reachable for logic the survey did not cover.

Translation check: N7:0 reads element 0, N7:52 reads element 52, and N7:147 reads element 147. Spot-check those three against the cross-reference list before going further. B3 maps the same way, word for word.

Test screen: pick the busiest of the ten. That screen references 12 of the 96 words, and 2 of the 12 are operator writes. Practice the writes on the scratch word first: write a value from the panel to N7:200, watch N7[200] change online in the controller, then confirm a real setpoint write.

Result: 256-element N7 and B3 arrays cover all 96 addresses the screens use, the 12-word test screen reads correctly, both writes land in the intended elements, and nothing was retyped. The same project copy then carries the remaining nine screens.

Convert and verify one copied screen

1. Copy the panel project and work only on the copy. The original stays untouched as the rollback.
2. Apply the import or the array map to the copy, and clear every unresolved reference the software reports before you open a screen.
3. Match the communication parameters in the driver: the L32E's IP address and route replace the old serial link settings. If the panel keeps a serial link, check the driver list before tuning serial settings.
4. Open the one test screen and check each object: assigned tag, data type, scaling, and read or write direction.
5. Go online with the L32E and compare every displayed value on that screen against the controller's own value.
6. Test the writes, starting with the scratch word N7[200] and then the real setpoints, while the machine is in a state where a wrong value cannot start anything. Bench-test the pair before installation when the procedure allows it.
7. Check the indirect tag users on the same screen: alarms, visibility conditions and color states read the mapped addresses too.
8. When the test screen passes, repeat steps 2 through 7 for the remaining nine screens, one at a time.

When a value reads wrong after the map, work in this order: communication parameters, then array element, then data type, then the object's own tag assignment. An off-by-one element is the easiest to spot, because the object shows a neighboring word's value. Strings are a separate trap: a blank string from a CompactLogix source is usually byte order, and the fix walk-through for a blank string from a CompactLogix PLC covers it.

How you know it worked

The map is finished when four things hold on the test screen:

• Every displayed value matches the controller's online value, word for word.
• A write from the panel changes exactly one mapped element, watched online, and nothing else moves.
• The software reports no unresolved references after the import or the map.
• The alarms on the screen fire on the correct bits.

Keep the cross-reference sheet with the panel prints afterward. The next engineer who adds a screen needs the old address, the array name, and the element it became.

Recommendation: map N7 and B3 to arrays that keep the old file names, size them to cover the highest address in use plus one, and prove the result on one copied screen with 12 checked values and 2 verified writes before converting the other nine. Take the panel software's tag-import path only where its application note documents it for your software version, and still verify one copied screen first.

Questions