Configuring 5069-IB16 Input Data as an INT in Ladder

You see 16 separate BOOL input points on the 5069-IB16, but no obvious input word to move into an INT. In the point-based Data format, one MOV or COP cannot gather those named BOOL members into a word. Start by checking whether the module definition offers Packed Data; use its generated packed member when available, or keep explicit bit mapping inside one reusable AOI or routine.

Read the symptom before changing logic

Start here. Expand the module-defined input tag in Logix Designer and inspect the actual members created by the selected module definition.

The familiar ladder pattern is valid but verbose:

XIC Local:6:I.Pt00.Data  OTE DI_01.0
XIC Local:6:I.Pt01.Data  OTE DI_01.1
...
XIC Local:6:I.Pt15.Data  OTE DI_01.15

That is not a communication fault. It is a datatype and representation issue.

Understand why a single copy fails

MOV transfers or converts one numeric source value. It does not traverse a structure, select 16 BOOL members, and assemble them into destination bits. COP copies contiguous storage according to the destination element count; it does not interpret member names or discard unrelated status members.

The point-oriented module-defined type includes individual data, fault, and uncertain indications. Those fields serve channel diagnostics, but they prevent you from treating the complete structure as though it were a plain 16-bit input word.

The controller also receives I/O updates independently of normal ladder execution. Reading 16 live BOOLs on 16 separate rungs can produce a mixed image if the module update occurs partway through the mapping sequence. Calling the routine first improves program organization, but scan position alone does not freeze the producer data.

A packed integer source gives the task one grouped value to snapshot. Where a larger contiguous source must be protected against an asynchronous update, use CPS after confirming the exact source and destination layouts. Do not copy the complete module-defined structure into an arbitrary INT array and search for the bits; status fields and type layout make that approach brittle.

Select the correct module data format

Open the module definition and look for the stated Data and Packed Data choices. Choose based on the application interface:

• Keep point-oriented Data when channel diagnostics and readable point members are the main requirement.
• Select Packed Data when the application, OPC interface, or reusable machine code needs a grouped input value.
• If both process bits and detailed status are required, retain diagnostic access and create a dedicated application snapshot. Do not replace diagnostic handling with the packed word.

Changing the format changes the module-defined tag layout. Review every existing reference before accepting the change, then compile the project and inspect the newly generated input members. Do not type a presumed packed member name from another module family.

Rockwell Automation Tech Note 790954 addresses converting these module data back to integers. Use that document when the generated packed layout or the required conversion is unclear; it is the reference for the product-specific member selection.

Build the input snapshot procedure

1. Create a controller-scoped or program-scoped INT destination such as DI_01. Use the scope required by the consuming logic or OPC connection.
2. Open the 5069-IB16 module definition and record whether it uses Data or Packed Data.
3. If project requirements permit, select Packed Data, accept the regenerated type, and compile. Repair references affected by the format change before continuing.
4. Expand the generated input tag. Identify the packed input member and its datatype from Logix Designer; do not infer it from the 1769 family or another 5069 module.
5. If the packed member is already a compatible scalar, place a MOV from that member to DI_01. If raw contiguous copying is required, configure COP or CPS only after matching the source size, destination type, and instruction length.
6. Remember that copy length is counted in destination elements, not bytes. A length of 1 means one destination element; it does not automatically mean one module or one complete structure.
7. Call the mapping routine once at the beginning of the task execution path. Reference DI_01 everywhere else during that pass instead of reading Local:6:I.Pt00.Data through Local:6:I.Pt15.Data again.
8. If no addressable packed scalar is generated, retain the 16 explicit assignments. Encapsulate them in an AOI or dedicated routine so the application uses one interface and the channel mapping remains reviewable.

Use CPS when a multi-element source must remain coherent while it is copied. It does not repair an incorrect structure overlay, source offset, destination type, or length.

Verify every channel and the scan snapshot

1. Start with every physical input off and confirm that the process bits in DI_01 read zero.
2. Activate point 0 only. Confirm DI_01.0 is set and the word displays 16#0001.
3. Repeat for each point. Point 1 should produce 16#0002; point 15 should produce 16#8000.
4. Activate all 16 points and confirm the bit pattern is 16#FFFF. A signed INT may display this as -1; compare the binary or hexadecimal pattern.
5. Monitor the packed source, DI_01, and the consuming logic together. Confirm the destination updates once at the mapping point and remains the only input image used for the rest of the task.
6. Check fault and uncertain indications separately. A correct process word does not prove that every channel value is valid.

If the bit order does not match the physical point numbers, stop and recheck the selected member and datatype. Do not compensate with undocumented offsets until the project tag definition and Tech Note 790954 have been checked.

Avoid the recurring dead ends

• Do not apply MOV directly to the point-based module structure. The source is not one numeric value.
• Do not assume a COP from the full module tag will select only the 16 input states. Fault and uncertain fields are part of the type.
• Do not reuse a mapping written for a 1769 module without inspecting the 5069-generated datatype.
• Do not hard-code a copy length because another card used 1. Confirm destination element size and the source region first.
• Do not rely on routine order while later logic continues to read live module points. The snapshot works only when all consumers use the mapped tag.
• Do not treat a negative decimal INT as failed mapping. Inspect bit 15 and the hexadecimal representation.
• Do not expect an input conversion to solve output packing. Writing a 5069 output module is a separate mapping decision and must follow its generated output datatype.

FAQ