Generating Instance Data Blocks in STEP 7 V5.5: SFC 22 Method

Overview

In SIMATIC STEP 7 V5.5 (and the S7-300/S7-400 CPU families that ship with it), engineers frequently ask whether the runtime program can mint a brand new Instance Data Block (IDB) the moment a process condition becomes true. The field-tested answer is: the CPU exposes a system function that creates a shared (global) DB at runtime — SFC 22 "CREAT_DB" — but the strict "Instance of FBx" relationship can only be assigned at compile time, or when the source is imported through an STL source file. This reference documents both paths, the precise parameter set, the error codes that surface in the RET_VAL word, and the limits you will hit on real hardware.

The reference target is STEP 7 V5.5 SP4 (or later SP) and any S7-300/S7-400 CPU whose firmware supports the SFCs in the "Standard Library → System Function Blocks" container. For S7-1500 work, the same idea is implemented through the "Create DB" instruction in the TIA Portal; the runtime mechanism is fundamentally different and is documented separately in the S7-1500 system manual.

Instance DB vs. Global DB — Why the Distinction Matters

Before you call CREAT_DB, you need to understand what an Instance Data Block actually is in the STEP 7 programming model:

• Instance DB (IDB): Memory that stores the static (STAT) interface variables of a single Function Block call. The offline editor binds the DB to a specific FB number, the FB symbol can be addressed symbolically inside the instance, and the symbol table is generated with the FB name as the instance qualifier (for example, "Instance_DB".Motor_Speed).
• Global DB (also called Shared DB): A standalone block of memory. All address references in the program go through the global symbol table, and any FB, FC, or OB can read or write its tags. There is no inherent binding to a particular FB.

At the byte level, a CPU-315-2 PN/DP treats them identically — a block header followed by a contiguous byte range. The "Instance" qualifier exists only in the offline block container and in the symbol table that STEP 7 generates. Consequently, the question "can I create an IDB from code?" is really two questions: can I create a block of memory with the right size at runtime (yes, via SFC 22), and can I make the editor and monitoring tools treat that memory as an instance of FBx from a PLC program (no — this requires a programming station).

Method 1 — Runtime Generation with SFC 22 "CREAT_DB"

SFC 22 lives in the "Standard Library → System Function Blocks" program and is callable from any OB, FB, or FC. It allocates a free DB number in the work memory of the CPU and initializes the block header. Once created, the block survives a warm restart, because the system persists its existence in the module's block list — though its initial values are restored on unbuffered restart.

SFC 22 Interface

SFC 22 Error Codes

Sample STL Call in OB1

// OB1 — STL call of SFC 22 "CREAT_DB"
      L     200                // desired DB number
      T     MW    100
      L     256                // 256 bytes (must be even)
      T     MW    104
      CALL  SFC   22
       DB_NUMBER :=MW100
       DB_LENGTH :=MW104
       RET_VAL   :=MW200
      L     MW    200           // capture return / assigned number
      L     0
      <>I
      JC    ALRM               // branch to alarm block on error
      OPN   DB   200           // open the freshly created DB
      L     0
      T     DBD    0           // initialize byte 0 with 0
ALRM: NOP   0

Sample Ladder (FBD) Call

// OB1 — Ladder (FBD) call of SFC 22
//  [CREATE_DB]
//       DB_NUMBER := MW100      // desired DB number (0 = auto-assign)
//       DB_LENGTH := MW104      // length in bytes
//       RET_VAL   := MW200      // error or assigned number
//  --( #DB_OK )----------------  // rung continues when RET_VAL = 0

Method 2 — Compile-Time Generation via STL Source Files

The "STL source file" route is the classic way to mass-produce blocks without clicking through the SIMATIC Manager GUI. An STL source is a plain-text file with .awl extension that contains the source representation of one or more blocks. When you compile the source, STEP 7 reconstructs the offline block container and assigns the FB/DB relationships on the programming station — which is precisely what the runtime CREAT_DB call cannot do.

Chapter 13 of the SIMATIC Programming with STEP 7 V5.5 manual walks through the entire source-file workflow. The general structure for an Instance Data Block is:

// STL source file (.awl) — Instance DB for FB1
DATA_BLOCK DB 20
TITLE = 'Instance of FB1 - Mixer'
AUTHOR : ENG
FAMILY : 'PROCESS'
KNOW_HOW_PROTECT
VERSION : 1.0
// Instance declaration matches FB1 STAT section
  STRUCT
    Motor_Speed   : REAL ;      // rpm
    Heater_On     : BOOL  ;
    Recipe_Count  : INT   ;
    Pressure      : REAL  ;
  END_STRUCT ;
END_DATA_BLOCK

To bind the block to FB1 explicitly (so the editor lists it as an instance and exposes FB1's symbol scope), the header is amended with the FB keyword:

DATA_BLOCK DB 20
FB 1
TITLE = 'Instance of FB1 - Mixer'
  STRUCT
    Motor_Speed   : REAL ;
    Heater_On     : BOOL ;
    Recipe_Count  : INT  ;
    Pressure      : REAL ;
  END_STRUCT ;
END_DATA_BLOCK

To import the source, place the file in the S7 program's "Sources" folder, right-click → Compile, and STEP 7 will deposit the freshly built DB into the Blocks container ready for download. This is the only way to author an "Instance of FB" with editor-grade fidelity, and it works equally well from a script (e.g., Excel VBA exporting .awl lines) for batch DB generation.

Step-by-Step — Implementing SFC 22 in OB1

1. Open the project in SIMATIC Manager. Navigate to your S7 program, then Blocks, and double-click OB1 to launch the LAD/FBD/STL editor.
2. Allocate working memory for the call. In the symbol table, define DB_REQ_NO (WORD, address MW100) and DB_REQ_LEN (WORD, address MW104). Reserve MW200 for the return value.
3. Wire your trigger condition. In a network upstream of SFC 22, build a one-shot (POS edge) so the create call only runs once when the process condition is met — repeated calls will re-issue error 80A1.
4. Insert SFC 22. From the program elements catalog, expand "Standard Library → System Function Blocks" and drag SFC 22 onto the network. Assign the parameter symbols as listed in the interface table above.
5. Evaluate RET_VAL. Add an unwind step that branches on the error code (e.g., jumps to an alarm FB if MW200 ≠ 0). For DB_NUMBER = 0 on input, MW200 contains the assigned number; copy it into your recipe block for later UDT-style access.
6. Initialize the new DB. Open the new block with OPN DB and use T instructions to set up the field defaults. The block's initial values from the offline project are not applied — SFC 22 produces an empty block.
7. Save, compile, and download. Use "PLC → Download" to push OB1 to the target. Trigger the condition in the running PLC and verify the new DB appears in the online block list ("PLC → Accessible Nodes → Blocks").

Step-by-Step — Generating an IDB from an STL Source File

1. Open the "Sources" folder. In SIMATIC Manager, expand your S7 program and select the Sources container. From the menu choose Insert → S7 Software → STL Source.
2. Name the source. Use a descriptive name (e.g., Mixer_Recipe_Sources). Double-click to open the source editor.
3. Type the block definition. Use the DATA_BLOCK / FB syntax shown in Method 2. Pay attention to the closing semicolons and END_DATA_BLOCK — the parser is unforgiving.
4. Save the source. File → Save (Ctrl+S). Do not close the editor yet.
5. Compile the source. Source → Compile, or right-click in the Sources folder and select Compile. STEP 7 reports any syntax errors in a dialog; double-click each entry to navigate.
6. Verify the DB in the Blocks container. Open the Blocks folder. The new DB should appear with the icon for an instance block (a stacked-file glyph) when bound with FB 1.
7. Download the block. Select the DB, then PLC → Download, or drag it from the offline Blocks to the online target.

Decision Flow — SFC 22 Runtime Creation

Limitations and Field-Proven Caveats

• IDB binding is offline-only. An IDB created at runtime through SFC 22 will be listed in the online "Accessible Nodes" view as a shared (global) DB. Symbolic FB-instance access will not resolve unless you pre-allocate the symbol with a placeholder DB number that matches what the runtime eventually uses — and even then, the FB-instance view in STEP 7 cannot be regenerated online.
• Work memory vs. load memory. SFC 22 creates the block in work memory only. If the CPU performs an unbuffered power-on restart, the DB is regenerated and its contents revert to zero. To persist data, write it to a retentive area or use a flash card with SAVE in OB121/OB122 handling.
• Block count ceiling. S7-300 CPUs cap the number of blocks at the lower of (a) the configured maximum in the CPU properties and (b) work-memory availability. A CPU 314C-2 PN/DP, for example, defaults to 1024 blocks; you can raise it in the hardware configuration up to the CPU-specific ceiling (commonly 256–2048 FBs/DBs/FCs combined).
• DB_NUMBER = 0 and race conditions. Passing 0 to obtain an auto-assigned number is fine, but you must immediately capture the RET_VAL before any other code opens a DB. The OPN DB instruction will overwrite the address register, and the next block open will re-bind the AR — a frequent cause of mystery data corruption in dynamic recipes.
• Watchdog exposure. SFC 22 execution time scales with the requested length. A 60 KB block on an S7-315 can push the OB1 cycle time by 5–8 ms. Always benchmark in OB35 (cyclic interrupt) rather than OB1 to keep the main scan deterministic.
• Online block delete before recreate. If your process requires replacing an existing DB with a new length, call SFC 23 "DEL_DB" first. SFC 22 will reject the call with 80A1 otherwise.
• Know-how protection on the source. The KNOW_HOW_PROTECT keyword in the STL source protects the compiled block from being opened in the editor, but it does not obscure the source file itself. If you need the source to remain secret, compile the STL on the engineering station and distribute only the compiled .s7p blocks.

Verification

After either method, run the following checks:

1. Online block visibility. PLC → Accessible Nodes → select the target CPU → Blocks. The new DB number must appear in the list, with a "work memory" date stamp matching the trigger event.
2. Symbol resolution. Open a VAT (Variable Table) and force a write to a symbol inside the new DB. If the symbol resolves, the block is in work memory and the symbol table is consistent.
3. Cross-reference. In the SIMATIC Manager, right-click the new DB → Cross-References. The list must show the FB call sites that reference it (only for true IDBs created via the source-file method).
4. Diagnostic buffer. PG → PLC → Diagnostic Buffer. Look for OB121/OB122 events around the time of creation — those indicate size or address violations that RET_VAL alone may have masked.
5. Cycle time trend. Add a watch on OB1's local "scan time" tags before and after the CREAT_DB call. A delta greater than your worst-case budget means the call should move to a slower OB (OB35 / OB82).

Troubleshooting Matrix

Cross-References and Companion SFCs

For the canonical reference of SFC 22, SFC 23, and SFC 24 interface definitions, see the S7-300/400 System and Standard Functions reference manual. For source-file syntax, the SIMATIC Programming with STEP 7 V5.5 manual is the authoritative source.

Frequently Asked Questions