Converting Siemens S5 C DB 0 to STEP 7: Migration Guide

When modernising a SIMATIC S5 application, one of the most common stumbling blocks is the data block call sequence. The S5 source fragment below contains a complete conditional branch built around the C DB 0 instruction. STEP 7 (S7-300/S7-400) does not expose C DB directly — the instruction is replaced by OPN DB (German AUF DB), and several related operands must be rewritten. This article walks through every line of the example, the S5-to-S7 mapping rules, and the verification steps required to commission the converted STL.

:L KF 261
:-F
:L FW 205
:SLW 1
:>=F
:JC =M006
:L KH F002
:C DB 0
M006 :L KB 31
M008 :T DW 1
:DO DW 1
:L DW 0
:T FW 220

1. Overview

Siemens introduced the SIMATIC S5 family in 1975 and supported it through several CPU generations (S5-90U, S5-95U, S5-100U, S5-115U, S5-135U, S5-155U). S5 programs were written in STL (Statement List), LAD (Ladder Diagram), or CSF (Control System Flowchart). The data block model used the call syntax C DB <number> to activate a DB for the subsequent DO (Datenoperand) accesses.

STEP 7, the programming environment for the SIMATIC S7-300 and S7-400 (and later the S7-1200/1500 in TIA Portal), introduced a more explicit data block model. The DB must be opened with OPN DB (or OPN DI for instance DBs), and the absolute data word inside the block is addressed as DBW n, DBB n, or DBD n with byte-based offsets. S7 drops the DO prefix entirely: with a DB open, the operand is just DBW, DBB, or DBD.

The conversion path for the source fragment requires three distinct translations:

• Replace the S5 constant load mnemonic L KH with the S7 word-typed literal L W#16#.
• Replace the S5 C DB x instruction with the S7 OPN DB x instruction.
• Replace the S5 DO DW n data operand with the S7 absolute operand DBW (2*n) referencing the previously opened DB.

2. Prerequisites

Perform the conversion on a workstation that meets the STEP 7 installation requirements and that has access to the official Siemens documentation portal.

Reference documentation is available from the Siemens Industry Online Support portal at support.industry.siemens.com. The migration manual cited in the original inquiry is the “From S5 to S7 Converter Manual”, published under entry ID 1118413.

3. Anatomy of the Source S5 Code Block

The S5 fragment is a conditional branch with a real-arithmetic preamble, a comparison against a flag-word-derived threshold, a conditional jump, and a data block activation that is only reached when the comparison fails. The final four instructions are common-path operations that run regardless of the branch outcome.

4. S5 Instruction Reference Table

Use this lookup table to translate other S5 operations that may appear in the same program block. Only the operators encountered in this example and their direct S7 equivalents are listed; consult the Siemens S7-300/400 STL manual for the complete instruction set.

5. Mapping S5 C DB 0 to STEP 7 OPN DB 0

The S5 C DB 0 instruction performs two semantic actions in a single statement:

1. It registers data block 0 as the “currently open” DB for the program scope.
2. It pushes the previously open DB and the previous DB register onto the S5 call stack (binary stack) so that DO and T data-operand accesses target DB 0 until a new C DB is issued.

STEP 7 exposes the same concept with OPN DB n (English; German AUF DB n). Unlike S5, S7 does not maintain a deep call stack for DB activations — the most recently opened DB and instance DB are held in two dedicated registers (DB and DI). For a single-thread conversion the S5 behaviour maps directly to S7 OPN DB.

// S5
:L KH F002
:C DB 0
M006 :L KB 31
M008 :T DW 1
:DO DW 1

// S7 (English STL)
      L     W#16#F002
      OPN   DB    0              // activate DB 0
M006: L     B#16#31
M008: T     DBW   2              // DW 1 in S5 = byte offset 2 in S7
      L     DBW   2              // read back DW 1 from DB 0

For multi-instance scenarios, where a function block already opened an instance DB with OPN DI, the S5 stack behaviour must be re-implemented using temporary DB pointers or by passing the DB number via an input parameter. The original S5 fragment does not use instance DBs, so a plain OPN DB is sufficient.

6. Handling L KH F002 → L W#16#F002

The S5 mnemonic L KH stands for “Lade Konstante Hexadezimal” (load hexadecimal constant). The operand is a four-digit hexadecimal value, e.g. F002, that is loaded into the low word of accumulator 1. The high word of ACCU 1 is cleared.

STEP 7 requires the operand type to be specified explicitly. The S7 equivalent of a 16-bit hexadecimal constant is the word-typed literal W#16#hhhh. The mapping is:

For 32-bit hex constants, S5 had no direct equivalent; users loaded two words in sequence. S7 supports L DW#16#hhhh_hhhh for double-word hex literals, and L 2#0000_0000_0000_0010 for explicit binary literals when the bit pattern is more readable than hex.

7. Translating DO DW 1 to DBW 2

The S5 DO DW n (Datenoperand Datenwort n) reads a 16-bit word at position n from the open DB. The numbering convention is word-indexed: DW 0 occupies the first 16 bits (bytes 0–1), DW 1 the next 16 bits (bytes 2–3), and so on.

STEP 7 addresses data words by byte offset, not by word index. DBW 0 covers bytes 0–1, DBW 2 covers bytes 2–3, etc. The conversion rule is therefore:

S7 offset (bytes) = 2 × S5 word index

8. Full S7 STL Equivalent with Comments

The complete converted routine, preserving the original control flow, looks as follows. The branch structure is identical; only the operator mnemonics and operand addresses change.

// S7-300/400 STL (English) - converted from S5 source
// Source: S5-115U STL listing, 13 instructions
// Target: STEP 7 V5.x, S7-300 CPU 31x

      L     261                  // S5: L KF 261
      NEGR                       // S5: -F  (negate real, treats 261 as REAL)
      L     MW   205             // S5: L FW 205   (flag word 205 → merker word 205)
      SLW   1                    // S5: SLW 1      (shift left word by 1 bit)
      >=R                        // S5: >=F       (real greater-or-equal compare)
      JC    JMP_OVER             // S5: JC =M006

// Fall-through path (comparison false)
      L     W#16#F002            // S5: L KH F002 (hex constant F002)
      OPN   DB    0              // S5: C DB 0    (open data block 0)

// Common path
JMP_OVER:
      L     B#16#31              // S5: L KB 31   (load byte 31)
      T     DBW   2              // S5: T DW 1    (write to DW 1, byte offset 2 in DB 0)
      L     DBW   2              // S5: DO DW 1   (read back DW 1)
      L     DBW   0              // S5: L DW 0    (read DW 0)
      T     MW   220             // S5: T FW 220  (transfer to flag word 220 → merker word)

Four subtle differences are worth flagging:

• Real vs integer arithmetic. S5's -F and >=F operate on the 16-bit fixed-point operand loaded by L KF 261 as if it were a real (16-bit floating-point in S5). STEP 7 separates integer and real arithmetic. The literal 261 loaded into ACCU 1 is treated as a 16-bit integer; NEGR then negates the integer. >=R will interpret both operands as 32-bit IEEE-754 reals. If the source S5 program uses 16-bit reals, you must convert to 32-bit REAL or replace the comparison with >=I (integer compare).
• Merker word address collision. Flag words (FW) in S5 are mapped to merker words (MW) in S7, but the byte/word bit boundary must be aligned. S5 flag words are 16-bit, while S7 merker words may share bytes between adjacent words. If the program accesses both MW 205 and MW 204, the S7 mapping can produce byte overlap that did not exist in S5. Use bit-granular merker addresses (M 0.0, MB 200, etc.) for clarity.
• DB 0 content. In S5, DB 0 is reserved and cannot be edited by the user. In S7, DB 0 is also reserved by the system for the bit memory image. Writing to DBW 0 in S7 will fail at compile time or in the CPU diagnostic buffer with SF (system fault). Replace the target with a custom data block such as DB 100 and update the OPN accordingly.
• SLW shift count limit. S5 SLW permitted shift counts of 0 to 15 (and in some dialects 0 to 16). S7 restricts SLW to 0 to 15. A shift count of 16 must be implemented with SLD on a double word, or by splitting the operation.

9. Using the Official Siemens S5 to S7 Converter

Siemens publishes a free conversion utility and accompanying manual under the title “From S5 to S7 Converter Manual”, entry ID 1118413 in the Siemens Industry Online Support portal. The converter automates the bulk of mechanical translation (mnemonic replacement, block structuring) but leaves semantic decisions to the engineer.

1. Open the S5 project in STEP 7 (V5.5 or later) using the S5 to S7 Converter wizard from the SIMATIC Manager File menu.
2. Select the S5 program files (.S5D) to be converted. The tool produces a sibling S7 project with the same name.
3. Review the conversion log. The tool emits warnings for any S5 constructs it cannot map one-to-one. Pay special attention to warnings about C DB with non-constant operand numbers and to DO FW/DW accesses with index expressions.
4. Open the converted STL blocks in the LAD/FBD/STL editor. Replace any user-opened DB 0 with a project-specific data block. The converter cannot determine the user's intent for DB 0 because the system reserves it in both S5 and S7.
5. Insert the S7 program into the target S7 CPU. Compile with Build / Save All and resolve any remaining syntax errors.
6. Download to the S7 CPU (online → download to target device). Observe the diagnostic buffer for any block-consistency errors at start-up.

The full manual is available at Siemens Industry Online Support — entry 1118413.

10. Verification & Commissioning

After the conversion, perform a structured verification on the S7 CPU before the program touches the process.

1. Static review. Open the converted STL block and check the sequence against the original S5 listing. Confirm that every C DB n in S5 became OPN DB n in S7, and that no DO DW survives unconverted. The STEP 7 compiler will accept a stray DO only as an undefined symbol, so any left-over S5 mnemonic will fail compilation.
2. Compiler feedback. Use PLC → Compile All (or the menu command Program → Compile). Resolve all warnings, not just errors. The Siemens compiler often flags “address area overlap” between adjacent merker words — fix these by re-aligning the merker declarations.
3. Offline simulation. Use the S7-PLCSIM optional package to run the converted program against simulated I/O. Force MW 205 to 130 (so that MW 205 × 2 = 260 < 261) and observe whether the fall-through path executes. Then force MW 205 to 131 (so that MW 205 × 2 = 262 ≥ 261) and confirm the JC branch is taken. The expected outputs are:
   • At MW 205 = 130: DBW 2 = 31 written at M008, MW 220 receives the value of DBW 0.
   • At MW 205 = 131: DBW 2 = 31 written at M006, MW 220 receives the value of DBW 0; the L KH F002 and C DB 0 instructions are skipped.
4. Online check on real CPU. Connect the programming device online, place the program in RUN, and use a VAT (Variable Table) to monitor MW 205, DB0.DBW 0, DB0.DBW 2, and MW 220. Toggle the inputs that drive MW 205 in the source process to verify both branches of the conditional.
5. Diagnostic buffer. Read the CPU diagnostic buffer with PLC → Diagnostic Buffer. Look for “block not found” (DB not loaded), “addressing error”, or “FATAL error”. Any of these indicates a residual S5 construct that the converter could not translate.

11. Common Pitfalls and Field Notes

When the converted program enters service, document the mapping in a migration memo. Record the S5 source block number, the S7 target block (FB / FC / DB), the merker remapping table, and any S5 instructions that required semantic changes. The memo becomes the authoritative cross-reference for the next maintenance engineer.

FAQ