Siemens SCL: Extract 16 Bits from a WORD Using AT Overlay

Overview

Field devices and legacy protocols frequently deliver status information as a single 16-bit WORD (for example, a digital input word from a remote I/O station, a status register from a frequency inverter, or a packed bit field received over Modbus). Downstream code, however, normally needs each bit as a discrete BOOL for visualization in HMI tags, interlocking in safety logic, or step enabling in a sequence. This article shows the canonical Siemens SCL pattern to break a WORD into sixteen BOOL outputs, and documents the equivalent STL and ladder techniques used on S7-300/400 and S7-1200/1500 controllers.

The reference pattern is the AT overlay — a SCL language element that lets you declare an alternative view over an existing variable without copying data. AT overlays are evaluated at compile time, produce zero runtime overhead, and are supported on every S7-1200 and S7-1500 firmware, as well as on S7-300/400 via STEP 7 V5.x SCL.

WORD Data Type and Bit Layout in the S7 Architecture

A WORD in the Siemens S7 data model is an unsigned 16-bit container occupying two bytes. The bit numbering is fixed by the architecture:

The S7 family is little-endian on the load-memory / process-image boundary, but the bit order within a word is always LSB = bit 0. A WORD in STEP 7 is a bit string, not a numeric value; use INT or DINT if signed arithmetic is required. The BOOL array produced by the patterns below preserves that order, so bitArray[0] = bit 0 (LSB) and bitArray[15] = bit 15 (MSB).

Prerequisites

1. Controller: SIMATIC S7-1200 (firmware V4.2 or later) or S7-1500 (firmware V1.0 or later). The AT overlay is supported on both. S7-300/400 users need STEP 7 V5.5 SP2 or later with the SCL option installed.
2. Engineering tool: TIA Portal V16 or later (V18 recommended for current firmware support). S7-300/400 users need SIMATIC Manager with SCL option installed.
3. Project: A configured PLC device with an OB1 (or a cyclic interrupt OB) ready to call the new block.
4. Source tag: An input tag of type WORD or UINT that carries the packed bit field.
5. Destination tags: Sixteen BOOL tags, declared in a global DB, an instance DB, or directly at the FC output interface.

Reference: SIMATIC S7-1200 product page for firmware and TIA Portal compatibility.

Step-by-Step: SCL AT Overlay Implementation

The AT overlay is the cleanest, fastest, and most portable solution. It declares a STRUCT view (or an ARRAY OF BOOL) on top of an existing variable so the compiler reinterprets the memory rather than copies it.

Step 1 - Create a new function (FC)

In the project tree, expand Program blocks, right-click and select Add new block > Function (FC). Name the block WordToBits, pick SCL as the implementation language, and select Void as the return type. The block number must be unique within the CPU (for example 999, the same number used in the original STL example).

Step 2 - Declare the interface

Open the FC and switch to the SCL source. Enter the following declaration section:

FUNCTION "WordToBits" : Void
{ S7_Optimized_Access := 'TRUE' }

VAR_INPUT
  inWord : WORD;
END_VAR

VAR_OUTPUT
  outBit00 : BOOL;
  outBit01 : BOOL;
  outBit02 : BOOL;
  outBit03 : BOOL;
  outBit04 : BOOL;
  outBit05 : BOOL;
  outBit06 : BOOL;
  outBit07 : BOOL;
  outBit08 : BOOL;
  outBit09 : BOOL;
  outBit10 : BOOL;
  outBit11 : BOOL;
  outBit12 : BOOL;
  outBit13 : BOOL;
  outBit14 : BOOL;
  outBit15 : BOOL;
END_VAR

VAR
  // AT overlay: reinterprets inWord as a structure of 16 BOOLs.
  // No data is copied; the overlay shares the memory of inWord.
  inBits AT inWord : STRUCT
    bit0  : BOOL;
    bit1  : BOOL;
    bit2  : BOOL;
    bit3  : BOOL;
    bit4  : BOOL;
    bit5  : BOOL;
    bit6  : BOOL;
    bit7  : BOOL;
    bit8  : BOOL;
    bit9  : BOOL;
    bit10 : BOOL;
    bit11 : BOOL;
    bit12 : BOOL;
    bit13 : BOOL;
    bit14 : BOOL;
    bit15 : BOOL;
  END_STRUCT;
END_VAR

With { S7_Optimized_Access := 'TRUE' } the block stores its data in the optimized symbol area. AT overlays on optimized blocks are allowed as long as the base variable is a tag (input, output, in/out, static, or global) — never a literal or a constant.

Step 3 - Implement the code section

BEGIN
  outBit00 := inBits.bit0;
  outBit01 := inBits.bit1;
  outBit02 := inBits.bit2;
  outBit03 := inBits.bit3;
  outBit04 := inBits.bit4;
  outBit05 := inBits.bit5;
  outBit06 := inBits.bit6;
  outBit07 := inBits.bit7;
  outBit08 := inBits.bit8;
  outBit09 := inBits.bit9;
  outBit10 := inBits.bit10;
  outBit11 := inBits.bit11;
  outBit12 := inBits.bit12;
  outBit13 := inBits.bit13;
  outBit14 := inBits.bit14;
  outBit15 := inBits.bit15;
END_FUNCTION

Step 4 - Call the FC from OB1

Open OB1, insert a new network, drag WordToBits from the project tree to the network, and connect the input to a tag of type WORD (for example "Data".statusWord from a Modbus holding register). Connect each outBitxx to the BOOL tags that your HMI or downstream logic uses.

Reference: Siemens Industry Online Support for SCL language reference and block attributes documentation.

Alternative SCL: Array of BOOL Overlay

For applications that pass the resulting bit pattern into a FOR loop (for example to drive sixteen output coils, to build a 16-bit mask, or to feed an HMI array tag), an ARRAY overlay is more compact and indexable:

FUNCTION "WordToBitsArray" : Void
{ S7_Optimized_Access := 'TRUE' }

VAR_INPUT
  inWord : WORD;
END_VAR

VAR_OUTPUT
  outBits : ARRAY[0..15] OF BOOL;
END_VAR

VAR
  inBits AT inWord : ARRAY[0..15] OF BOOL;
END_VAR

BEGIN
  // One move: the array view shares memory with outBits after a single assignment.
  outBits := inBits;
END_FUNCTION

This version produces an array you can scan with a FOR i := 0 TO 15 DO loop. With optimization enabled, the compiler typically generates a single 16-bit block move.

Reference: SIMATIC S7-1500 product page for the SCL AT-view declaration rules.

STL Implementation Using the L-Stack Trick

The classic S7-300/400 STL approach exploits the fact that the local data area of an FC/FB is a contiguous scratch memory starting at LW0. By ordering the TEMP variables deliberately, you can transfer a 16-bit word into LW0 and read its bits directly as BOOL temps.

FUNCTION FC 999
TITLE = WordToBits
VERSION : 0.1
VAR_INPUT
  in : WORD;
END_VAR
VAR_OUTPUT
  out0  : BOOL; out1  : BOOL; out2  : BOOL; out3  : BOOL;
  out4  : BOOL; out5  : BOOL; out6  : BOOL; out7  : BOOL;
  out8  : BOOL; out9  : BOOL; out10 : BOOL; out11 : BOOL;
  out12 : BOOL; out13 : BOOL; out14 : BOOL; out15 : BOOL;
END_VAR
VAR_TEMP
  // DECLARATION ORDER MATTERS: tmp0..tmp15 occupy the bits of LW0.
  // In S7-300/400, BOOL temps are packed into bytes from low to high.
  // Layout: byte 0 = tmp0..tmp7 (LSB = tmp0), byte 1 = tmp8..tmp15.
  tmp0  : BOOL; tmp1  : BOOL; tmp2  : BOOL; tmp3  : BOOL;
  tmp4  : BOOL; tmp5  : BOOL; tmp6  : BOOL; tmp7  : BOOL;
  tmp8  : BOOL; tmp9  : BOOL; tmp10 : BOOL; tmp11 : BOOL;
  tmp12 : BOOL; tmp13 : BOOL; tmp14 : BOOL; tmp15 : BOOL;
END_VAR
BEGIN
  NETWORK
  TITLE = Move input to local word 0
  L  #in;
  T  LW 0;          // LW 0 now mirrors the 16 bits of #in.
  NOP 0;

  NETWORK
  TITLE = Map bit 0
  U   #tmp0;
  =   #out0;
  // (Repeat for bits 1..15 in subsequent networks.)
END_FUNCTION

On S7-1200 and S7-1500 this trick is not necessary and is in fact discouraged because the optimized block storage means the compiler is free to re-lay the temp area. Use the AT overlay for those CPUs.

Reference: SIMATIC S7-1200 product page for the optimized-block rules that make the L-stack trick obsolete on the newer CPUs.

Ladder Logic Implementation

On a programming environment where SCL is not licensed, the same function can be built in KOP/FBD by extracting each bit with the AND word operation. The pattern is identical to a typical "bit de-multiplexer":

NETWORK 1  // Extract bit 0
L   #inWord;
L   W#16#0001;
UW  ;                 // AND with mask 0x0001
SRW 1;                // shift right 1 position (optional, to normalize)
T   #outBit00;        // result is 0 or 1 in INT

Repeat the pattern with masks W#16#0002, W#16#0004, ..., W#16#8000 and a right shift of n positions to land each bit in outBit0n. This ladder form executes in roughly 2 µs per bit on an S7-1516, fully equivalent to the AT overlay, but it costs 16 networks and 16 scratch words.

For a fully graphical representation, TIA Portal's LAD editor also offers the Word AND and Word shift right boxes. The KOP editor on TIA Portal V18 supports the AT view via the Slice access notation, allowing "tag".%X0 through "tag".%X15 as direct bit references on a WORD tag — no FC needed.

Reference: Siemens Industry Online Support for the LAD/FBD editor documentation and the SCL language reference.

FC vs FB Selection

Use an FC unless you specifically need a static instance DB. The decision matrix:

For a bit-split function, the FC is the right choice in 95% of cases. The L-stack overhead is irrelevant (a few microseconds at the OB1 call site) and you avoid allocating an instance DB for what is essentially a pure function.

Reference: SIMATIC S7-1500 product page for the FC/FB selection guide.

Bit Ordering, Modbus, and Cross-Platform Caveats

Several scenarios demand attention to bit ordering:

1. Modbus master: A Modbus holding register returns 16 bits numbered 0 (LSB) to 15 (MSB) when interpreted as an unsigned integer. The AT overlay above preserves this order; no swap is required.
2. PROFIBUS / PROFINET packed I/O: Slot-level packed I/O arrives byte-wise. The first byte received is the low byte of the WORD, the second byte is the high byte. Bits 0..7 of the WORD live in the first byte received from the device — exactly what the overlay shows.
3. Big-endian field device: Some Modbus slaves document the high byte as the "first" register. Use a WORD to WORD swap (rotate word left/right by 8) before applying the overlay. TIA Portal offers the ROTATE instruction in the Word logic palette.
4. Safety-related bit fields: If the source is a fail-safe (F-) input word, do not perform the split inside the F-runtime group. Hand the F-word to the standard runtime group as a non-safety tag and split it there, otherwise the F-system will reject the unknown instruction.
5. Sign extension with INT: If the base tag is INT instead of WORD, the bit layout is identical, but reading bits 0..14 is fine — bit 15 is the sign bit. Use WORD when the bit pattern is a status field, not a numeric value.

Common Use Cases (Modbus, PROFINET, HMI)

For HMI integration, expose the sixteen outBitxx outputs as separate HMI tags in the WinCC tag management; the HMI can then bind them to individual indicators or to a 16-position bitmap. Do not bind the original WORD to the HMI directly — splitting it on the PLC side keeps the HMI configuration simple and lets other blocks reuse the same bit pattern.

Verification and Commissioning

After downloading the block to the CPU, validate the conversion with a watch table and a forced pattern. The procedure is identical for S7-300, S7-1200 and S7-1500:

1. Open Watch and force tables > Add new watch table.
2. Add the input WORD tag and the sixteen BOOL outputs.
3. Click Modify > Modify with explicit values on the input tag. Enter 16#AAAA (binary 1010_1010_1010_1010) and apply. The expected pattern is outBit15, outBit13, outBit11, outBit9, outBit7, outBit5, outBit3, outBit1 = TRUE; the rest FALSE.
4. Repeat with 16#5555 (binary 0101_0101_0101_0101). Expect the inverse of the previous pattern: even-numbered bits TRUE, odd-numbered bits FALSE.
5. Test 16#0001 (only bit 0 TRUE), 16#8000 (only bit 15 TRUE), and 16#FFFF (all TRUE). Three passes is the minimum for sign-off.
6. Capture the OB1 scan time before and after adding the block. On an S7-1516 the increase is below 1 µs; on an S7-1212 it is between 5 µs and 10 µs.
7. Optionally write a self-test in OB100 (startup) that loads 16#0001, 16#0002, 16#0004...16#8000 in sequence and asserts that only the corresponding output is TRUE; a mismatch halts the CPU and surfaces the error in the diagnostic buffer.

Reference: SIMATIC S7-1200 product page for the "Monitoring and modifying tags" section in the system manual.

Troubleshooting Matrix

Reference: Siemens Industry Online Support for the SCL compile error reference and the safety-runtime programming rules.

FAQ