A well-designed PLC program goes beyond basic functionality, incorporating clear comments, robust architecture, scalability, comprehensive alarm systems, and pre-deployment simulation capabilities.
Design Requirements for PLC Programs
Simplicity
PLC programs should be as simple as possible, using standardized frameworks and straightforward instructions. Optimize the program structure with flow control instructions to simplify logic. Use high-functionality instructions to replace basic ones and arrange instructions logically to enhance clarity.
Readability
Programs must be readable to facilitate debugging, maintenance, and collaboration. Achieve clarity through structured, modular, and hierarchical designs, ideally using object-oriented principles. Prefer ladder logic over other programming languages for better readability unless specific requirements dictate otherwise.
Organize I/O assignments systematically to aid memory and understanding, and include comments where necessary. Use internal devices consistently to avoid confusion. Plan for readability from the start, accounting for potential changes during debugging, and refine the program post-debugging to maintain clarity.
Essential comments include:
- System comments: Program purpose and copyright details.
- Program block comments: Purpose and author of each block.
- Segment comments: Functionality of code segments.
- Variable comments: Descriptions for I/O and intermediate variables.
For confidentiality, use encryption algorithms or block-level encryption rather than reducing comments.
Accuracy
PLC programs must function correctly, validated through real-world testing. Accurate instruction usage requires a clear understanding of instruction meanings and conditions. Test unclear instructions with small programs if needed. Check programming manuals for instruction variations across PLC models or batches.
Use internal devices appropriately, ensuring power-loss protection where required. For example, Siemens rising and falling edge detection requires storage-capable variables like M or DB points, not temporary FC variables, to avoid errors.
Reliability
Beyond accuracy, programs must be reliable under non-standard conditions, such as power interruptions or improper operations. Reliable programs detect and handle abnormal conditions, seamlessly transitioning to normal operation, and reject illegal operations without residual effects. Interlocking, inherited from relay circuits, is an effective method to prevent invalid operations.
Modifiability
Programs should be easy to modify to adapt to changing requirements. PLC flexibility allows modifications without extensive rewrites. Design programs with elasticity, enabling parameter changes or action adjustments with minimal effort. For significant process changes, redesign may involve I/O reassignment, but most cases require only minor tweaks.
Scalability
Programs should accommodate future expansions. Reserve space in each functional section for additional code and ensure hardware has sufficient capacity. Account for manual, automatic, and semi-automatic modes during software design to facilitate future enhancements.
Comprehensive Alarm System
In industrial settings, robust alarm and protection systems are critical to minimize losses from incidents. Prioritize preemptive accident handling and loss mitigation through well-designed alarm mechanisms.
Simulation Capabilities
Before deployment, simulate programs fully to ensure functionality and demonstrate to clients. Include simulation code that converts I/O points to intermediate variables or data blocks and develop equipment-specific simulation routines. Disconnect simulation code during live operation.
PLC Programming Standards
Adhere to these guidelines for consistent and reliable PLC programming:
- Select appropriate PLC models and I/O points, using special modules for specific functions.
- Familiarize yourself with the PLC¡¯s programming instructions and software.
- Plan soft elements, including internal relays, holding relays, data registers, timers, and counters.
- Structure programs in the sequence of fault detection, fault handling, manual processing, automatic processing, and output handling. For large projects, segment code by functional units (e.g., conveyor, lift, rotation device).
- Precede each program segment with concise comments explaining its function, optionally referencing the process flow. Arrange segments in process order for readability.
- Abstract equipment behavior before coding, extracting common factors like stop, emergency stop, overload, or safety switches. Place these in startup or interlock circuits as program prerequisites, then divide code into automatic and manual functional zones.
- In manual mode, extract factors like manual operation or safety risks, placing them in interlock circuits for protection and alarms.
- In automatic mode, extract factors like limits or timeouts, integrating them into interlock circuits for equipment protection and alarms. Prioritize safety by strictly limiting inputs and loosely restricting outputs.
- Include a global reset function to safely restore equipment after faults, ensuring personnel and equipment safety during reset.
- Clear automatic mode outputs and states when switching to manual mode, especially for SET instructions, using RESET in manual mode.
- Avoid double outputs (same output coil used multiple times). Use intermediate relays to consolidate outputs under different conditions.
- For touchscreens, reserve shared control and status areas exclusively for PLC-touchscreen communication.
- Verify special module control and status areas to avoid conflicts with other programming tasks.
- Annotate all inputs, outputs, relays, timers, counters, and registers with clear, unambiguous Chinese comments, including component names and noting NC contacts where applicable.
- Archive final software post-commissioning, naming files with project number, author, date, and version.
- Store encryption passwords in a dedicated file, shared with at least two authorized individuals, to prevent access issues.
Programming Recommendations
- For HMI or touchscreen systems, use a MOV instruction to manage control modes (e.g., manual = 1, automatic = 2 in register VB10) for clear mode detection without complex interlocking.
- For analog control, apply time-based filtering for stable signals or averaging for noisy signals. Refer to relevant literature for advanced filtering techniques.
- During debugging, if a condition is met but the output coil does not activate, check for JUMP or interrupt statements that may skip the code segment.
- For sequential control, use a +10 increment in a register to track steps (e.g., 10 = first action, 20 = second). This allows easy insertion of steps and action jumps (+20, +30) as needed.
- Maintain fault conditions with visual or audible alarms until operator reset to ensure awareness of process issues, avoiding misattribution to the control system.
- Encapsulate frequently used subroutines as reusable modules.
- Implement step-timeout protection by starting a timer (set 20¨C30% longer than normal step duration) at each step. Trigger alarms or shutdowns if the step exceeds the time limit.
- Use normally closed (NC) inputs for safety switches like emergency stops or limit switches.
- Design outputs to activate only when needed and stop once completed, rather than remaining active by default.
- Ensure actuators remain inactive over erratic movement for safety.
- For single equipment, include soft manual/automatic switching. Equipment should not stop when switching to manual, but automatic mode depends on program logic.
- For pumps, fans, or large equipment, enforce 24-hour rotation with runtime tracking unless overridden by HMI or operator settings.
