Recipe Changes Don’t Apply on Roll Forming Machines — Tag Mapping & Version Mismatch Troubleshooting

Introduction — When Recipe Changes Don’t Affect Production

Modern roll forming machines often rely on recipe systems to store and manage product configurations.

Recipes may contain parameters such as:

• panel length
• punch spacing
• line speed limits
• cut compensation offsets
• stacker counts.

Operators select recipes through the HMI, and the PLC loads the parameters into the machine control logic.

However, sometimes operators change a recipe and nothing happens. The machine continues to run with the previous settings.

Typical symptoms include:

• new panel length not applied
• punch pattern unchanged
• speed limits remain the same
• stacker counts incorrect.

These problems usually originate from:

• tag mapping errors
• recipe version mismatch
• incorrect PLC logic for loading recipes
• HMI configuration issues.

This guide explains how to diagnose and resolve these issues.

How Recipe Systems Work in Roll Forming Machines

Before troubleshooting, it is important to understand how recipes normally function.

A typical recipe process follows these steps:

1 operator selects a recipe on the HMI
2 HMI loads recipe parameters
3 HMI writes parameters to PLC tags
4 PLC copies parameters to active machine settings
5 machine runs using the new values.

If any step fails, the machine may continue using old parameters.

Symptom 1 — Recipe Appears to Load but Machine Behavior Doesn’t Change

This is one of the most common problems.

The operator selects a new recipe, but the machine continues operating with the previous parameters.

Possible causes include:

• incorrect PLC tag mapping
• PLC not copying recipe values to active variables
• wrong parameter references in the program.

Root Cause 1 — HMI Tag Mapping Errors

Each recipe parameter must be mapped to the correct PLC tag.

Example:

Recipe panel length → PLC tag Cfg_PanelLength.

If the HMI writes to the wrong tag, the PLC program may never see the updated value.

Common tag mapping mistakes include:

• incorrect tag names
• outdated addresses after PLC program updates
• duplicate tags used in different screens.

Technicians should verify that each recipe field writes to the correct PLC variable.

Root Cause 2 — PLC Program Not Applying Recipe Values

In many PLC programs, recipe parameters are stored in a configuration structure.

However, the machine may use a separate set of active runtime values.

Example:

Recipe value:

Cfg_PanelLength = 6000 mm

Active runtime value:

Run_PanelLength = 6000 mm

If the PLC does not copy the recipe value into the runtime variable, the machine will continue using the old value.

Engineers should verify that the recipe load logic updates the active machine parameters.

Root Cause 3 — Recipe Load Command Missing

Some machines require an explicit Load Recipe command.

Changing recipe values alone may not activate them.

Typical sequence:

1 operator edits recipe parameters
2 operator presses Load Recipe
3 PLC copies parameters into active machine variables.

If the load command is missing or incorrectly programmed, the machine will ignore the new values.

Root Cause 4 — Version Mismatch Between HMI and PLC

Sometimes the HMI and PLC software versions do not match.

This can happen when:

• PLC program updated but HMI project not updated
• new recipe parameters added to PLC
• HMI still using an older configuration.

In this situation, the HMI may write parameters to outdated or incorrect PLC tags.

The result is that the PLC receives incomplete recipe data.

Synchronizing the HMI and PLC projects usually resolves this issue.

Root Cause 5 — Parameter Scaling Differences

Another common issue occurs when the HMI and PLC use different units.

Example:

HMI displays panel length in millimeters.

PLC expects value in meters.

Operator enters:

6000 mm

PLC interprets as:

6000 meters.

To prevent this, scaling factors must be defined correctly.

Root Cause 6 — Recipe Locked During Production

Some machines prevent recipe changes while production is running.

This protects the machine from unexpected parameter changes.

If an operator attempts to modify a recipe while the machine is running, the PLC may ignore the new values.

Operators should verify that the machine is in the correct mode for recipe editing.

Root Cause 7 — Incorrect User Permissions

Recipe modification may be restricted by user access levels.

Typical permission levels include:

• operator
• supervisor
• engineer.

If an operator lacks permission to modify recipes, the HMI may ignore their changes.

Logging in with the correct user role may resolve the problem.

Root Cause 8 — Data Storage Problems

Recipes are often stored in memory structures such as:

• PLC data blocks
• HMI internal databases
• external SQL systems.

If the storage system fails, recipe changes may not be saved correctly.

Possible causes include:

• memory corruption
• communication interruptions
• storage configuration errors.

Technicians should verify that recipe values persist after power cycles.

Root Cause 9 — PLC Program Using Hardcoded Values

Sometimes PLC logic still uses fixed values instead of recipe variables.

Example:

Program uses:

PanelLength = 6000

Instead of:

PanelLength = Cfg_PanelLength

In this case, changing the recipe will not affect machine operation.

Engineers must ensure that all adjustable parameters reference recipe variables.

Troubleshooting Procedure

Technicians should follow a structured process to identify the problem.

Step 1 — Verify Recipe Change on HMI

Confirm that the new value appears correctly on the HMI.

Step 2 — Check PLC Tag Value

Verify that the PLC tag changes when the recipe is loaded.

Step 3 — Confirm Runtime Parameter Update

Ensure the PLC copies the recipe value into the active machine variable.

Step 4 — Verify PLC Logic References

Check that machine logic uses the recipe variable.

Step 5 — Check HMI and PLC Version Compatibility

Confirm both systems use the same software configuration.

Commissioning Best Practices for Recipe Systems

During machine commissioning, engineers should verify recipe functionality thoroughly.

Typical tests include:

1 loading multiple recipes
2 verifying parameter updates in the PLC
3 running test panels with different settings
4 confirming correct product output.

These tests ensure that recipe systems function correctly before production begins.

Preventing Recipe Problems

Several best practices reduce the risk of recipe errors.

Recommended practices include:

• clear tag naming conventions
• centralized recipe data structures
• version control for HMI and PLC projects
• operator confirmation prompts when loading recipes.

These practices improve reliability.

Production Impact of Recipe Errors

If recipe systems malfunction, several problems may occur:

• incorrect panel lengths
• misaligned punching patterns
• production downtime
• increased scrap material.

Reliable recipe management is essential for flexible roll forming production.

Benefits of Proper Recipe Integration

When recipe systems are implemented correctly, they provide several advantages.

These include:

• fast product changeovers
• consistent product quality
• simplified machine setup
• improved production efficiency.

For roll forming manufacturers producing multiple product types, reliable recipe systems are critical.

FAQ — Recipe Changes Not Working

Why doesn’t my roll forming machine apply new recipe values?

Common causes include incorrect tag mapping, missing load commands, or PLC logic using fixed values instead of recipe variables.

How can I verify that the PLC received the new recipe value?

Monitor the recipe parameter tag in the PLC diagnostics after loading the recipe.

What causes recipe version mismatch?

Version mismatch occurs when the HMI and PLC projects are updated independently and no longer share the same parameter structure.

Why might recipe changes be ignored during production?

Some machines block recipe changes while running to prevent unexpected machine behavior.

Can operator permissions prevent recipe changes?

Yes. Many systems restrict recipe editing to supervisors or engineers.

How can engineers prevent recipe problems?

By using clear tag naming, proper version control, and thorough commissioning tests.