WinCC V7.0 Recipe Management: User Archives vs DB Approach

Overview

Recipe management in Siemens WinCC V7.0 (including SP2, SP3 and SP4) is not delivered as a single configurable object the way that recipe elements are exposed in WinCC Flexible, TIA Portal, or WinCC RT Professional. Engineers building on a WinCC V7.0 runtime must assemble recipe capability from one of three patterns: the optional User Archives package, a controller-side STEP7 DB-based scheme that uses SFC20 BLKMOV to copy recipe data into an active data block, or a migration to a platform with a built-in recipe editor. Each approach has a different footprint in terms of licensing, programming effort, scalability, runtime user-friendliness, and migration risk.

This reference consolidates the engineering trade-offs of each option, documents the SFC20 block-copy pattern in detail, lists the licensing exposure for User Archives, and includes a known-issues matrix that addresses the User Archive Control crash and User Archive editor usability problems observed on WinCC V7.0 SP2 and later. Where a project is greenfield, the article also maps the migration path to WinCC RT Professional recipe functions for engineers who want a fully integrated recipe object.

Recipe Management Options in WinCC V7.0

WinCC V7.0 is delivered with three primitives that can be combined into a recipe system, plus two alternative platforms that already include a recipe object.

WinCC User Archives (option package)

User Archives (UA) is a separately licensed WinCC option that exposes a table editor in the WinCC Explorer and a runtime control that can be dropped onto a process picture. Recipes are stored as rows in a SQL Server table; the data is held in the runtime database and read into the PLC on demand through tags or scripts. The UA control gives operators a tabular view with add, edit, delete, and import/export (CSV) capabilities. The package was designed for recipes but its UI was never re-engineered for large recipe sets, and it shows its age on V7.0.

STEP7 DB-based recipe scheme

All recipe data is stored in STEP7 data blocks on the S7 controller. Each recipe is its own DB; a dedicated "active recipe" DB holds the recipe currently being executed. A small piece of STEP7 logic uses SFC20 BLKMOV to copy the entire contents of a selected recipe DB into the active recipe DB. Editing is performed in a separate "edit" DB that the operator's recipe screen writes to, with a "Save to recipe N" action that copies the edit DB back into the chosen recipe DB using SFC20 in the reverse direction. This pattern uses no additional WinCC option and scales well for small to medium recipe counts (less than 50 in practice).

Migration to WinCC Flexible / WinCC RT Professional

WinCC Flexible (for Comfort Panels, TP/OP panels, and Mobile Panels) and WinCC RT Professional (the TIA Portal based PC runtime) include a built-in Recipe object with a configurable editor, transfer list, recipe view control, and tag binding. The runtime recipe element is part of the base engineering environment and does not require an additional option. Existing WinCC V7.0 systems cannot host the new recipe element; migration requires moving the project to TIA Portal and re-engineering the HMI portion.

WinCC User Archives: Architecture and Constraints

User Archives is implemented as a SQL Server database table inside the WinCC runtime database. The WinCC Explorer → User Archive editor lets the engineer define columns (one column per recipe parameter) and a row limit. At runtime, the User Archive Control (inserted from the WinCC Graphics Designer control palette) renders the table to the operator and provides inline editing, filtering, and CSV import/export.

From the PLC side, data exchange is performed through WinCC tags. Each column of the archive can be bound to one or more tags; the archive control calls uaArchiveRead and uaArchiveWrite internally as values change. For larger recipes, scripting with VBS in the Graphics Designer is usually required to orchestrate the read/write sequence and to handle acknowledgement back to the PLC.

Documented limitations

• Editor usability: the column editor in WinCC Explorer is text-only and offers no group/folder structure. Recipes with more than 30 columns become hard to navigate.
• Control ergonomics: the runtime UA control was not redesigned for high-resolution panels; the grid is small and not touch-optimized.
• No native versioning: changes overwrite prior values; there is no built-in history of recipe edits.
• Licensing: User Archives is a separately licensed WinCC option. The base WinCC RT license does not include the option. Each operator station that displays or edits the archive may require the option license on its RT key (refer to the WinCC V7.0 price list for the exact option designation).
• Scale: because the UA table is held in the WinCC runtime database, the practical upper bound is determined by SQL Server Express limits, which on V7.0 SP2+ is 4 GB per database and a row count that depends on column count. In real installations, performance begins to degrade well before SQL Server limits when row count exceeds a few thousand.

STEP7 DB-Based Recipe Management with SFC20

The DB-based pattern uses the PLC's data block memory as the recipe store. Recipes are data blocks of identical structure; an "active recipe" data block holds the recipe currently in use; an "edit" data block holds a copy the operator is currently modifying.

DB structure

Each recipe data block has the same structure so that SFC20 can perform a full block copy. The parameter list and the order of parameters is the same across all recipe DBs, the active DB, and the edit DB.

SFC20 BLKMOV parameters

SFC20 (BLKMOV) is a system function call provided by the S7 CPU operating system. It copies a contiguous memory area to another contiguous memory area without requiring the engineer to write a loop.

Common SFC20 return values (refer to the STEP7 System Software / S7-300/400 System and Standard Functions manual for the complete list):

• W#16#0000 — no error
• W#16#8091 — source area exceeds the area limit
• W#16#8092 — destination area exceeds the area limit
• W#16#80B1 — source DB is not loaded
• W#16#80B2 — destination DB is not loaded
• W#16#80B4 — error in ANY pointer format

Sample STL call (copy recipe N to active DB)

// Assume recipe index is in MW 100 (1..99)
// Recipe N lives in DB (100 + N - 1) i.e. recipe 1 = DB100, recipe 99 = DB198
      L     MW 100
      +     99                  // recipe 1 -> DB 100
      T     #tempDB
      OPN   DB [#tempDB]
      CALL  SFC 20
       SRCBLK := P#DBX 0.0 BYTE 240
       RET_VAL := MW 102
       DSTBLK := P#DB200.DBX 0.0 BYTE 240

Sample SCL call

// SCL — copy recipe N to active DB
IF (recipeIndex >= 1) AND (recipeIndex <= 99) THEN
  SFC20(
    SRCBLK := P#DB[100 + recipeIndex - 1].DBX 0.0 BYTE 240,
    RET_VAL := retVal,
    DSTBLK := P#DB200.DBX 0.0 BYTE 240
  );
END_IF;

WinCC side: tag binding and operator screen

On the WinCC side, expose the active DB and the edit DB as WinCC tags by configuring the STEP7 connection in WinCC Explorer and creating tags that map to the offsets in DB200 and DB201. The operator screen typically has three areas: a recipe selector, a parameter grid that binds to the edit DB tags, and action buttons (Load, Save, Cancel).

For the recipe selector, use a WinCC combo box bound to a WinCC tag that the operator writes. The HMI script then computes the source DB number and triggers a bit that the STEP7 logic monitors (e.g., M 200.0 = "Copy recipe to active", M 200.1 = "Save edit DB to recipe"). The STEP7 logic checks the bit, performs the SFC20 call, and clears the bit when done.

Side-by-Side Comparison

Decision Criteria: When to Use Which Method

Use the matrix below as a quick field test.

Licensing Exposure

User Archives is licensed as a WinCC option. The exact designation is WinCC/User Archives (also called WinCC option: User Archives). It is delivered as a separate license key that is bound to the same WinCC authorization (the License Key Plug or the Automation License Manager) as the base WinCC RT license.

Confirm the current option designation on the Siemens Industry Mall or the WinCC V7.0 price list. The "User Archives" option has historically been delivered as a single-station key for engineering and a runtime-bound option for each runtime instance that uses the archive.

Implementing the STEP7 DB Method

The implementation is split between STEP7 and WinCC. The PLC stores and copies; the HMI tags read and write.

STEP7 side

1. Define the recipe data type as a STRUCT in a global DB or as a UDT (user-defined data type) so that all recipe DBs share an identical layout. Example UDT name: UDT_RECIPE.
2. Create N recipe DBs of type ARRAY[1..P] OF REAL (or a UDT) using the same name pattern (DB100, DB101, ..., DB100+N-1).
3. Create the active DB (DB200) and the edit DB (DB201) with the same layout.
4. Implement a function block (e.g., FB200 "RECIPE_MGMT") that monitors the operator commands from WinCC:
   • Input bits from WinCC: LoadRecipe, SaveRecipe, Cancel
   • Inputs: RecipeIndex (INT), ParamCount (INT), ParamSize (INT)
   • Internally use SFC20 BLKMOV in both directions
   • Outputs: Done, Error, ErrorCode
5. On a successful copy, set the Done bit; on error, set Error and return the SFC20 return code in ErrorCode.

WinCC side

1. In the WinCC Tag Management, configure the STEP7 connection to the CPU and add tags for each parameter of the edit DB (DB201) and the active DB (DB200).
2. Add a recipe selector (WinCC combo box) that writes to a tag RecipeIndex.
3. Add a parameter grid (WinCC input/output fields) bound to the edit DB tags. Disable the input fields when no recipe is being edited.
4. Add action buttons that toggle the command bits on the PLC: "Load Recipe", "Save Recipe", "Cancel".
5. Use a small VBScript in the Graphics Designer to write the RecipeIndex and the ParamSize values, and to monitor the Done and Error tags for operator feedback.

Implementing the User Archives Method

1. Open the WinCC Explorer on the engineering station and navigate to User Archive.
2. Create a new archive (e.g., "Recipes"). Define one column per recipe parameter; choose a SQL data type appropriate to the parameter (FLOAT, INT, BOOL stored as INT 0/1, or CHAR/VARCHAR for text).
3. Add a primary key column ("RecipeID") and an optional "RecipeName" column. Mark "RecipeID" as the identifier.
4. On the runtime station, insert the User Archive Control from the Graphics Designer control palette onto a process picture. Bind the control to the archive name ("Recipes").
5. Configure the control's tag interface so the columns are connected to WinCC tags. For non-tag columns, leave the binding empty and use the control's VBScript API to read/write values.
6. Implement the "Load" / "Save" buttons using VBScript. Example pattern using the WinCC UA OLE interface:

   ' VBScript — read row 1 of archive "Recipes" into PLC tags
   Dim conn, rs
   Set conn = CreateObject("ADODB.Connection")
   conn.Provider = "WinCCOLEDBProvider.1"
   conn.Properties("Data Source") = HMIRuntime.ActiveProject.Name & "\"
   conn.Open
   Set rs = CreateObject("ADODB.Recordset")
   rs.Open "SELECT * FROM Recipes WHERE RecipeID = 1", conn
   HMIRuntime.Tags("Setpoint1").Write rs.Fields("Setpoint1").Value
   HMIRuntime.Tags("Setpoint2").Write rs.Fields("Setpoint2").Value
   rs.Close
   conn.Close
   

Migration to WinCC Flexible and WinCC RT Professional

For greenfield projects, the recipe object in WinCC Flexible and WinCC RT Professional removes most of the engineering effort described in the previous sections. The recipe element exposes a recipe view control that the engineer binds to a configurable list of tags, a CSV-based transfer mechanism, and a recipe editor that is part of the base engineering environment.

For TIA Portal projects, an official example of recipe functions in WinCC RT Professional is published in the Siemens documentation portal. The example covers read, write, and data-record transfer with the standard recipe scripting API and is a useful starting point when porting a WinCC V7.0 User Archives or DB-based recipe to TIA Portal.

For WinCC V7.0 → WinCC RT Professional migration, the typical path is to export the User Archives table (or the recipe DB contents) to CSV, then use the ImportDataRecords method to seed the new recipe element. The DB-based scheme requires manual recreation of the recipe data structure in TIA Portal because TIA does not import S7 classic DBs directly.

Known Issues and Workarounds

Performance and Scalability Considerations

For the DB method, the SFC20 call on an S7-300/400 executes in a deterministic time proportional to the number of bytes copied (approximately 1 ms per 100 bytes on a typical S7-315/317). For an S7-1500 the equivalent SFC (SFC20 is replaced by the MOVE_BLK instruction in TIA) executes faster. The recipe load is therefore a one-shot operation of typically 1–10 ms; it does not affect scan time in a meaningful way.

For the User Archives method, the limiting factor is the SQL Server round-trip. A typical read of 30 columns from a single row takes 50–200 ms over the WinCC OLE DB provider, depending on the SQL Server load and the network. For high-frequency recipe updates this is too slow; the DB method is preferred.

For a comparison of recipe counts:

• DB method: limit is PLC work memory. An S7-317 with 1 MB of work memory can store thousands of recipes if each recipe is small (a few dozen REALs). Practical upper bound on STEP7 V5.x is about 1,000 recipes of 240 bytes each.
• User Archives: limit is SQL Server database size. The WinCC runtime database on V7.0 SP2 and earlier is SQL Server 2005 Express (4 GB); on V7.0 SP3+ it can be SQL Server 2008 R2 Express (10 GB). Recipes with 30 columns of FLOAT occupy roughly 300 bytes per row plus indexing overhead; the practical limit is therefore around 1 million recipes before hitting the database ceiling.

FAQ