Recipe Management with Multiple S7-1200 CPUs in TIA Portal

Overview: Multi-CPU Recipe Architectures on S7-1200

The SIMATIC S7-1200 does not have a single "recipe DB" primitive like some older controllers; recipes are constructed from Data Blocks (DB) whose structures define parameter sets (records) and recipe headers (lists). When the application involves more than one S7-1200 CPU, valves, analog I/O, and multiple HMI / PC clients, the architecture decision becomes the engineering problem, not the recipe function call.

Before writing any code, lock down four constraints:

1. Authoritative copy location – where the canonical recipe dataset lives (one HMI, central PC, or PLC DB).
2. Write arbitration – how concurrent edits from multiple operator stations are resolved.
3. Distribution channel – how edited recipes are pushed back to all CPUs that need them.
4. Degraded mode – whether the line can keep producing when the supervisor PC, HMI, or a peer CPU drops out.

The answers select between three families: HMI-centric, PLC-centric (recipe in DBs), or server-centric (WinCC Professional / OPC UA / custom .NET service). The choice of TIA Portal vs PCS 7 vs WinCC Runtime Professional follows from that decision rather than the other way around.

Recipe Data Model on S7-1200

Each recipe has two parts in every CPU that participates:

• Recipe element DB – one DB containing the recipe header array and one or more record structures (e.g., "MyRecipe".Header[1..20], "MyRecipe".Element[1..50]).
• Runtime DB – a working DB that mirrors the active record, written by the HMI's recipe view and read by the process code.

Typical declarations in the recipe element DB (TIA Portal, SCL):

TYPE UDT_RecipeElement :
STRUCT
  name        : String[32];   // e.g. "Setpoint_Temp"
  unit        : String[8];    // e.g. "°C"
  value_min   : Real;         // low limit
  value_max   : Real;         // high limit
  value_def   : Real;         // default
  value_act   : Real;         // active runtime value
END_STRUCT
END_TYPE

The recipe array uses an array of this UDT. Element count and naming are dictated by the largest recipe in the system. Keep the structure identical across all participating CPUs – mismatched UDTs are the single most common cause of recipe-transfer faults when commissioning.

Storage Options Compared

For the original poster's described need (multiple operator PCs and HMIs editing the same recipes, fed to multiple S7-1200 CPUs), the canonical copy almost always lives outside the PLC – on a PC or shared folder – so all HMIs read the same file and editing is centralized.

Architecture A – HMI-Centric Recipe Distribution

Recommended topology for two to five S7-1200 CPUs and two to six HMIs/PC clients on one line:

• Master operator station: one PC running WinCC Runtime Professional or a Comfort Panel designated as recipe owner. All recipe CSV files live in its project folder.
• Read-only clients: additional Comfort Panels or RT Advanced stations that only view recipes and start batches. They read CSV from the master via network share.
• S7-1200 CPUs: hold the active record in DBs and execute the process. They receive the active record from the master HMI on batch start.

Recipe flow:

1. Operator edits recipe on master HMI; TIA Portal recipe view writes the change back to the master CSV.
2. On batch start, master HMI downloads the active record to the target CPU's runtime DB using standard recipe view transfer (write tags from the recipe view).
3. Slave CPUs receive setpoints from the master CPU over S7 communication (PUT/GET) or via shared HMI tags written to each connection.
4. Master HMI logs batch results to its recipe data log.

Architecture B – PLC-Centric with Web Server Recipes

S7-1200 firmware V4.0 and later exposes recipes as CSV files via the integrated web server. The recipe CSV is uploaded or downloaded through the CPU's web page, allowing any PC on the network to act as the editor without TIA Portal being installed.

Steps to enable and use web-server recipes (per the Siemens S7-1200 manual collection):

1. Activate the web server in the CPU properties ("Web server" → "Activate web server on this CPU").
2. Configure users and access rights under "Web server" → "User management". The "recipes" right controls who can read/write.
3. In the program, create or generate the recipe DB using RecipeExport / RecipeImport extended instructions (libraries: "Recipes" under Extended Instructions).
4. Open http://<cpu-ip>/recipes in a browser; the file browser page lists all recipe CSVs available on the load memory card.
5. Download a CSV, edit it offline, then upload the modified file back through the same page.

This topology suits installations where no PC is permanently online but engineers still need to update recipes remotely. It is not a true multi-client solution: only one user at a time should write a CSV, and concurrent uploads will overwrite.

Architecture C – Server-Centric (OPC UA or File Share)

For lines with regulatory audit requirements, version control, or more than ~10 concurrent recipe authors:

1. Store recipes on a central SQL or file-share server.
2. Use WinCC Professional's recipe system with a database backend (SQLite or MS SQL via OLE DB) so all RT clients read/write through the same dataset.
3. Push the active record to each S7-1200 over S7 communication; the HMI's "Recipe view" widget can target multiple PLC connections.
4. Optionally expose recipes via OPC UA: an S7-1200 firmware V4.4+ acts as OPC UA server, and a higher-level MES/ historian reads method calls or specific nodes. Reference the S7-1200 system manual for the OPC UA server configuration page.

Communication Setup: CPU-to-CPU with S7 Communication

When the master CPU must hand setpoints to slave CPUs (the "activate outputs to another CPU" requirement from the original poster), use the PUT / GET instructions or configured S7 connections:

• PUT: writes 1–212 bytes from local DB to a remote DB on partner CPU. Triggered by a one-shot on batch start.
• GET: reads the same to confirm and to fetch actual values for logging.

Connection setup in TIA Portal:

1. In the master CPU's device configuration, add an "S7 connection" under "Properties → Communication → S7 connections".
2. Enter the partner IP and the partner's rack/slot (always slot 1 for S7-1200).
3. Place PUT from "Communication → S7 Communication" with the partner connection ID, request DB, and remote target DB.
4. Configure PUT/GET access in the partner CPU under "Properties → Connection mechanisms → Permit access with PUT/GET from remote partner" – this must be enabled or the instruction returns error 0x80D2.

// Master CPU SCL snippet – send active recipe to slave CPU_2
#iState := PUT(
    REQ     := #bSendTrigger,        // pulse TRUE for one cycle on batch start
    ID      := 1,                    // connection ID from S7 connection table
    DONE    => #bDone,
    ERROR   => #bErr,
    STATUS  => #wStatus,
    ADDR_i  := P#DB20.DBX0.0 BYTE 200,   // local source: recipe runtime DB
    ADDR_o  := P#DB20.DBX0.0 BYTE 200);  // remote target: same offset in partner

IF #bErr THEN
    // 0x0001 = communication in progress, 0x80D2 = access denied, 0x80D4 = partner unreachable
    #sFault := 'PUT fault status=' + WORD_TO_STRING(#wStatus);
END_IF;

For more than three CPUs or large datasets, configure the connections in the device view rather than relying on ad-hoc PUTs – the connection table is then checked at compile time and downloaded with the project.

Commissioning Procedure

1. Define the recipe UDT once. Lock the structure, element count, units, and limits. Document the version of the UDT (e.g., UDT_RecipeElement_v1.0); every CPU must be at the same version before connecting.
2. Create one shared TIA Portal master project containing all CPUs, all HMIs, and the recipe view. Or use a multi-project if team size demands it (TIA Portal V14+ multi-project editing).
3. Configure connection rights. On every S7-1200, enable "Permit access with PUT/GET from remote partner" only if you intend to use that mechanism; otherwise keep it off and use only configured S7 connections.
4. Set the recipe storage path on the master HMI/PC. For a shared folder topology, use a UNC path, e.g., \\PLANT-SVR\Recipes\LineA\, and grant modify rights to the runtime service account.
5. Download all CPUs first, then the master HMI, then any read-only clients. Do not start recipe transfer until all are online – the recipe view will queue writes but errors during initial download are hard to interpret.
6. Verify by writing a known record to CPU_1 from the master HMI, then reading DB20.DBD0 directly via the online viewer. Repeat with a peer CPU using PUT.

Verification Checklist

Common Faults and Fixes

Best Practices and Field Notes

• One author per recipe at any moment. Use the HMI recipe view's "Data record is being edited" indicator (a global HMI tag) and gate write buttons on it. Without this, two operators can produce a torn write.
• Avoid optimized DB access for PUT/GET targets. PUT and GET can only address absolute byte offsets; if the partner DB is "optimized", mark the relevant areas with the AT view or disable optimization for that DB.
• Retain the active record. Set the runtime DB fields to retentive so a CPU restart does not blank the last-known-good setpoints before the next recipe download.
• Tag names, not addresses. Configure the recipe view against symbolic tag names. This decouples the recipe from any future DB restructuring.
• Engineer the limits in the UDT. Validation belongs in the PLC where it cannot be bypassed by a thin client. The HMI should reflect limits, not enforce them.
• Version the recipes. Include a recipe version tag in the UDT header. Reject downloads on the slave CPU when version mismatches.
• Match firmware. Keep all CPUs at the same firmware major version when sharing recipes – certain OPC UA nodes and extended instruction behaviors changed between V4.2, V4.4, and V4.5 of the S7-1200.

Choosing the Right Siemens Suite

The original poster asked which Siemens suite to use. For S7-1200 + multi-PC recipe management, the practical answer is:

• TIA Portal (mandatory) for PLC and HMI engineering.
• WinCC Runtime Advanced if all clients are SIMATIC Comfort Panels or single-user PCs.
• WinCC Runtime Professional if multiple PC clients, central recipe archive, or SQL-backed logging is required.
• PCS 7 – skip for S7-1200. PCS 7 targets AS 410 / S7-400 redundant controllers. Choosing PCS 7 for an S7-1200 line is the most common wrong-direction mistake for this scenario.

References for the recipe web server workflow and integrated recipe instructions are documented in the Siemens S7-1200 system manual collection and in the support entry "Using recipes with S7-1200" (entry ID 94681612).

FAQ