C135 PCS 7 (PCS7)
6C
6 Cielo Ciencia y Tecnología
·Publicada en C135 PCS 7 (PCS7)

Resolving S7 F-Systems Safety Compilation Errors: 64 KB Code Section Limits and F-Runtime Groups

Resolving S7 F-Systems Safety Compilation Errors: 64 KB Code Section Limits and F-Runtime Groups

To resolve the S7 F-Systems safety compilation error 'E: Maximum length of code area reached (max. 64 Kbytes)' and eliminate long compilation times (up to 90 minutes) in SIMATIC PCS 7, engineers must partition the safety program across multiple F-Runtime Groups. The underlying S7-400 architecture enforces a strict 64 KB code segment boundary on compiled function blocks. When an entire safety program is concentrated into a single monolithic runtime group within a cyclic interrupt OB (e.g., OB35), the generated safety driver logic, F-signatures, and cross-checks exceed this 64 KB limit. The resolution requires dividing the safety logic into multiple separate CFC charts assigned to distinct F-Runtime groups (e.g., @F_OB35_1, @F_OB35_2) or splitting logic between OB35 and OB36.

Table of Contents

The 64 KB Code Segment Boundary in S7-400 and F-Systems

In SIMATIC S7-400, S7-400H, and AS 410 controllers, the underlying CPU architecture enforces a strict hardware limitation on executable blocks:
* The 64 KB Boundary: No single compiled function block (FB), function (FC), or runtime code section can exceed 65,536 bytes (64 KB) of machine instructions.
* F-Compiler Code Inflation: When compiling a safety program via S7 F-Systems, the compiler does not simply compile user logic. It automatically injects fail-safe cross-checks, diversitary calculations, inverted logic channels, CRC signature calculators, and communication integrity blocks for every fail-safe block.
* Consequently, a user safety program that appears relatively modest in CFC can easily expand to exceed 64 KB of generated machine code if compiled as a single runtime entity.

Root Causes: Monolithic F-Runtime Groups and Compiler Timeouts

When a safety project experiences extreme compilation durations (60 to 90+ minutes) followed by compiler termination:

  1. Monolithic Runtime Groups: Placing all safety channel drivers (F_CH_DI, F_CH_AI, F_CH_DO) and emergency shutdown interlocks into the default runtime group @F_OB35 forces the F-compiler to generate a single massive FB containing all safety logic.
  2. Memory Segment Overflow: Once the generated instruction stream crosses 64 KB, the compiler issues:
    E: Maximum length of code area reached (max. 64 Kbytes).
  3. Internal Compiler Timeout / Abort: If an engineer reorganizes blocks superficially without structurally subdividing runtime groups, the compiler enters deep combinatorial dependency loops while resolving F-cycle signatures, eventually aborting with:
    E: Action terminated by user (even though the user never cancelled the operation).

Step-by-Step Architecture: Partitioning Logic Across Multiple F-Runtime Groups

To eliminate the 64 KB overflow and accelerate compilation times:

Step 1: Open the CFC Runtime Editor

  1. In SIMATIC Manager, open any CFC chart and execute Options -> Customize -> Compile/Download.
  2. Open the Runtime Editor (Ctrl+Shift+R or click the Runtime Group icon).
  3. Expand the cyclic interrupt OB assigned to safety (e.g., OB35).

Step 2: Create Multiple Distinct F-Runtime Groups

  1. Instead of a single @F_OB35 group, insert multiple F-Runtime groups:
    * @F_OB35_Inputs: Houses fail-safe input channel drivers (F_CH_DI, F_CH_AI).
    * @F_OB35_Logic1: Houses Emergency Stop and Fire & Gas interlock matrices.
    * @F_OB35_Logic2: Houses equipment protection and burner shutdown sequences.
    * @F_OB35_Outputs: Houses fail-safe output channel drivers (F_CH_DO, F_CH_AO).
  2. Ensure each F-Runtime group has the 'F-attribute' enabled.

Step 3: Reassign CFC Charts to Groups

  1. In CFC chart properties, assign separate safety charts to their designated F-Runtime groups.
  2. Verify that data flow between groups follows the logical execution sequence (Inputs -> Logic -> Outputs).

Step 4: Utilize Multiple Cyclic Interrupt OBs (If Necessary)

If the safety program is exceptionally large, distribute execution across multiple OBs (e.g., fast digital trips in OB35 at 100 ms, and slow analog temperature monitoring in OB36 at 500 ms).

Optimizing Safety Compilation Performance in S7 F-Systems

To reduce safety compilation times from 90 minutes down to under 5 minutes:

  1. Avoid Circular F-Connections: Never create backward interconnections between safety blocks that force the F-compiler to resolve iterative dependency graphs.
  2. Consolidate Communication Channels: Use F_CYC_CO (F-Cycle Communication) efficiently to minimize inter-OB data handshakes.
  3. Selective Chart Compilation: Once F-Runtime groups are partitioned, perform Changes Only compiles rather than Entire Program compiles during routine engineering iterations.
  4. Clean Staging Directories: Clear temporary files in <Project_Dir>\Global\s7finfo before executing major safety program updates.

Safety Program Structure and Runtime Group Parameter Matrix

The following table outlines the architectural sizing rules for S7 F-Systems runtime groups:

S7 F-Systems ParameterRecommended ThresholdMaximum Architectural LimitImpact of Exceeding ThresholdCode Area per F-Group<= 45 Kbytes64 Kbytes (Strict Hardware)Compiler aborts: 'Maximum length reached'Blocks per F-Group40 to 80 F-BlocksApplication dependentSluggish compilation, high execution jitterExecution OBsOB35 (100 ms) / OB36 (500 ms)OB30 to OB38Exceeding OB cycle time causes CPU STOPF-Compile Time2 to 5 minutes90+ minutes (Abnormal)Indicates circular references or single groupSafety Collective F-CRCRegenerated on change32-bit CRC hashValidates legal safety modification compliance

Partitioning safety logic into structured groups guarantees deterministic safety execution within SIL 3 / PLe boundaries.

Verification

To verify that the safety compilation error is permanently resolved:
1. In SIMATIC Manager, execute Options -> Edit Safety Program.
2. Click Compile Charts as Program; verify that compilation proceeds smoothly through all F-Runtime groups without hanging.
3. Confirm that compilation finishes with status: 'Compilation completed: 0 Errors, 0 Warnings' within 3 to 6 minutes.
4. Open the safety summary log; verify that each F-Runtime block registers a code size well below 64 KB (e.g., 35–45 KB).
5. Download the safety program; verify that the S7-400H controller enters RUN with the SAFE LED illuminated steadily.

Limitations and Operational Precautions

  • Modifying F-Runtime group structures alters the safety collective signature (F-CRC), requiring re-verification of the safety validation matrix according to IEC 61511.
  • Any download of structural safety program modifications requires placing the F-runtime in safety de-energized mode or stopping the CPU if safety password authorization is not established.
  • Do not mix standard non-safety blocks into F-Runtime groups; standard blocks must reside in separate, non-safety runtime groups.
  • Always validate final safety software licenses (S7 F-Systems Engineering and Runtime licenses) with an authorized Siemens distributor.

Engineer FAQ

Why does compiling a safety program take so much longer than standard CFC?

The F-compiler performs extensive mathematical and structural safety integrity checks, generates diversitary duplicate code, injects safety CRC calculators, and verifies fail-safe communication paths against IEC 61508 SIL 3 criteria.

Can I split my safety program between OB1 and OB35?

No. Fail-safe logic cannot execute in OB1. S7 F-Systems strictly requires execution within deterministic, cyclic interrupt OBs (OB30 through OB38) to guarantee fail-safe fault detection reaction times.

Where can I see the code size of each compiled F-Runtime group?

In SIMATIC Manager, open the block folder of the AS station. Sort blocks by size; inspect the generated safety function blocks (typically numbered FB 300+) to observe the exact byte size of each F-group.

Technical References

Related Articles

Related Tags

  • S7 F-Systems
  • Safety Compilation Error
  • 64 KB Code Limit
  • F-Runtime Groups
  • SIL 3 Architecture
6 respuestas