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

Resolving Maximum Length of Code Area Reached 64Kbytes Compiler Errors in PCS 7 CFC

Resolving Maximum Length of Code Area Reached 64Kbytes Compiler Errors in PCS 7 CFC

In SIMATIC PCS 7 (such as V8.2), the CFC compiler error 'Maximum length of code area reached (max 64Kbytes)' occurs because the SIMATIC S7-400 CPU architecture strictly limits the compiled machine code (MC7) size of any individual Function (FC) or Function Block (FB) to exactly 64 KB (65,536 bytes). When compiling a project with a large volume of redundant I/O modules (e.g., 86 redundant ET 200M modules on a CPU 414-5H), the automated module driver generator packs all diagnostic block calls (MOD_D1, OB_DIAG1) for an organization block into a single system FC (e.g., FC764). To resolve this, open the CFC Run Sequence (Edit > Run Sequence), locate the congested runtime group in the system chart (@), create a secondary runtime group within the same OB, and redistribute half of the driver block calls into the new group, or reorganize the AS project via SIMATIC Manager.

Table of Contents

Executive Summary

High-availability automation architectures in SIMATIC PCS 7 frequently utilize redundant distributed I/O modules across multiple ET 200M stations to eliminate single points of failure. When compiling the automation program with 'Generate module drivers' enabled, the PCS 7 driver generator automatically inspects HW Config redundancy settings and inserts diagnostic monitoring and redundancy driver blocks into system charts (@ charts).

However, in large I/O configurations executing on mid-range controllers—such as a CPU 414-5H supervising 86 redundant modules (172 physical I/O cards)—engineers frequently encounter a fatal compilation abort: 'Maximum length of code area reached (max 64Kbytes)'. Curiously, this compilation failure often appears after upgrading from PCS 7 V8.1 to V8.2, even when the project contains only a single user CFC chart. This issue is not a work memory exhaustion fault; it is an architectural code segment limit enforced by the S7-400 processor. This technical guide explains the 64 KB MC7 limit, identifies why V8.2 Basis Library blocks cause code expansion, and provides step-by-step procedures to split congested runtime groups and reorganize the AS program.

Architecture and Fundamental Mechanics

The compilation architecture of SIMATIC PCS 7 translates graphical charts into executable controller blocks subject to fixed CPU architectural boundaries:
1. The 64 KB Architectural Code Block Limit:
* In the SIMATIC S7-400 instruction set architecture, every compiled code block—whether a user-written Function (FC), Function Block (FB), or system block—is limited to a maximum code area of 64 Kilobytes (65,536 bytes).
* Even if the CPU possesses several megabytes of total work memory, no individual block can exceed 64 KB.
2. The Mechanism of Runtime Group Code Generation:
* During CFC compilation, the compiler translates each Runtime Group inside an Organization Block (e.g., OB35, OB82, OB86) into an intermediate SCL source file (@SCLFileFromCFC...), which is then compiled into a single executable Function (FC).
* When 'Generate module drivers' executes for 86 redundant I/O modules, the driver generator instantiates hundreds of MOD_D1, MOD_D2, and diagnostic wrapper calls into a single runtime group inside the system diagnostic charts (@SystemCharts).
* If the cumulative compiled instruction bytes of all block calls within that single runtime group exceed 65,536 bytes, the SCL/MC7 compiler halts with the error: 'Maximum length of code area reached (max 64Kbytes)'.
3. Why PCS 7 V8.2 Triggered the Limit Where V8.1 Passed:
* The PCS 7 Basis Library V8.2 introduced expanded diagnostic features, enhanced channel status structures, and extended error handling in module drivers.
* This added code footprint per driver instance slightly enlarged the compiled code per module. With 84 redundant modules, the generated code remained just under 64 KB; adding the 85th and 86th modules added several hundred bytes, breaching the 65,536-byte threshold and triggering the compilation abort.
4. Diagnostic SCL Compilation:
* The specific offending block can be identified by opening the S7 Program > Sources folder in SIMATIC Manager and compiling the generated @SCLFileFromCFC... source file directly, which outputs the exact line number and FC block number.

Step-by-Step Implementation Procedure

Step 1: Identify the Failing Runtime Group and Block Number

  1. In the CFC compilation error log, note the reported block number (e.g., FC764 or FC756).
  2. In SIMATIC Manager, navigate to the Blocks folder of the S7 Program.
  3. Locate the block (e.g., FC764) and inspect its comment or properties to identify which system chart or runtime group generated it.
  4. If the block was deleted due to compilation abort, open S7 Program > Sources, open the latest @SCLFileFromCFC... file, and select File > Compile to display the exact SCL source line that exceeded 64 KB.

Step 2: Open the CFC Run Sequence and Locate System Runtime Groups

  1. Open any CFC chart in the project.
  2. In the menu, select Edit > Run Sequence (or press Ctrl+R).
  3. In the Run Sequence window, expand the organization block where the module drivers execute (typically OB35 for cyclic monitoring or OB82/OB86 for diagnostic interrupts).
  4. Locate the congested runtime group in the @ chart (e.g., @OB35_ModuleDrivers).

Step 3: Split the Congested Runtime Group into Two Groups

  1. In the Run Sequence window, select the congested organization block.
  2. Right-click and select Insert Runtime Group.
  3. Name the new group (e.g., @OB35_ModuleDrivers_Part2).
  4. Select approximately half of the driver block calls (e.g., 40 module driver blocks) from the original group and drag-and-drop them into the newly created runtime group.
  5. Ensure the execution order of the two runtime groups is sequential.
  6. By splitting the blocks across two runtime groups, the compiler generates two separate, smaller Functions (e.g., each 32 KB), resolving the 64 KB overflow.

Step 4: Reorganize the AS Project Database

  1. Close all CFC charts and editors.
  2. In SIMATIC Manager, select the AS user project object.
  3. Right-click the Blocks folder and select Get Fill Level to evaluate database fragmentation.
  4. Select File > Reorganize....
  5. Click Yes to allow SIMATIC Manager to defragment the project database and clean orphaned cross-reference indices.

Step 5: Recompile CFC and Verify Successful Build

  1. Open the CFC Editor.
  2. Select Chart > Compile > Entire program (with 'Generate module drivers' enabled).
  3. Confirm that compilation completes with zero errors.
  4. In the Blocks folder, verify that no individual FC exceeds 64,000 bytes.

Verification

  1. In SIMATIC Manager, sort the Blocks folder by the 'Size in Work Memory' and 'Size in Load Memory' columns.
  2. Confirm that every compiled Function (FC) and Function Block (FB) has a code area size strictly under 64 KB.
  3. Open HW Config: verify that all 86 redundant ET 200M modules remain configured with active diagnostics.
  4. Download the compiled program to the AS controller (Target System > Download > Entire program).
  5. Place the CPU in RUN mode: confirm that OB82/OB86 diagnostic interrupts process normally and that WinCC displays valid process and diagnostic states.

Limitations and Operational Precautions

  1. The 64 KB block size limit is a hardwired architectural limit of SIMATIC S7-300 and S7-400 processors; software settings cannot expand an individual block's code area beyond 64 KB.
  2. When 'Generate module drivers' is executed subsequently, future hardware additions may re-congest the runtime group if not monitored.
  3. If an individual user CFC chart (rather than a driver group) exceeds 64 KB, the chart must be partitioned into multiple smaller sub-charts.
  4. If CPU work memory utilization exceeds 80%, consider splitting field I/O across two separate AS controllers (e.g., two CPU 414-5H stations) or modernizing to CPU 410-5H.

Engineer FAQ

Why does the 64 KB limit exist if my CPU has 4 MB of memory?

The 64 KB limit is a code segment addressing boundary within the S7-400 processor architecture. While total memory can be several megabytes, no single individual block (FC or FB) can exceed 64 KB of machine instructions.

Why did the project compile in PCS 7 V8.1 but fail in V8.2?

PCS 7 V8.2 Basis Library module drivers feature enhanced diagnostic capabilities and larger code sizes. With 86 redundant modules, the cumulative code crossed the 65,536-byte threshold in V8.2.

How do I split a runtime group?

In the CFC Run Sequence window (Ctrl+R), insert a new runtime group in the same OB and drag half of the blocks from the congested group into the new group.

Can an SFC Type trigger this 64 KB error?

Yes. An overly complex SFC Type containing dozens of steps, massive transition expressions, and numerous actions can exceed 64 KB and must be split into smaller, coordinated state machines.

Does CPU 410-5H suffer from the 64 KB code block limit?

While CPU 410-5H has a massive 48 MB memory pool and faster execution, individual compiled S7 blocks still respect standard SIMATIC block boundaries; runtime group splitting remains a best practice.

Technical References

Related Articles

Related Tags

  • 64Kbytes Limit
  • CFC Compile
  • Runtime Group
  • S7-400
  • Module Drivers
20 respuestas