PLC Counter Function Block: Build Custom Counters for Automation
Why Some PLCs Lack a Standard Counter Instruction
In many PLC programming environments, a counter instruction is a fundamental element. It typically includes an input to trigger counting, a reset input, and a preset value. When the accumulated count reaches the preset, an output bit turns on. However, not all PLCs offer this as a built-in function. Some compact or cost-optimized controllers may omit dedicated counter instructions, relying instead on more generic data manipulation commands. This can surprise engineers accustomed to brands like Siemens, Allen-Bradley, or Mitsubishi, where counters are standard. The absence of a counter instruction doesn’t mean counting is impossible—it just requires a different approach using basic arithmetic and logic.
Building a Custom Counter Function Block with INC
The INC (increment) instruction adds 1 to a specified memory word or data register on each execution. By wrapping this instruction inside a function block (FB), you can create a reusable counter that mimics the behavior of a dedicated counter. The FB can include inputs for count enable, reset, and preset value, and outputs for count reached and current count value. This modular design simplifies ladder logic and makes the program easier to maintain.
Example Counter FB Structure
- Input_Enable (BOOL): Rising edge triggers count increment.
- Input_Reset (BOOL): Resets accumulated count to zero.
- Input_Preset (INT): Target count value.
- Output_CountReached (BOOL): True when current count ≥ preset.
- Output_CurrentCount (INT): Current accumulated count.
Internally, the FB uses a one-shot (rising edge detection) to ensure the INC instruction executes only once per trigger event. The reset input clears the count register. A comparison block sets the output when the count meets or exceeds the preset.
Step-by-Step Implementation in Ladder Logic
Let’s walk through a typical implementation using a PLC that supports function blocks and the INC instruction. The following steps assume a basic understanding of ladder logic and tag-based addressing.
| Step | Action | Details |
|---|---|---|
| 1 | Create a new Function Block | Define inputs, outputs, and internal variables (e.g., Count_Register as INT, OneShot_Storage as BOOL). |
| 2 | Detect rising edge on enable | Use a contact from Input_Enable and a one-shot logic to generate a pulse. Store the previous state in OneShot_Storage. |
| 3 | Increment count on pulse | When the one-shot pulse is true, execute INC on Count_Register. |
| 4 | Handle reset | If Input_Reset is true, move 0 to Count_Register. |
| 5 | Compare with preset | Use a greater-than-or-equal comparison: if Count_Register ≥ Input_Preset, set Output_CountReached. |
| 6 | Output current count | Continuously move Count_Register to Output_CurrentCount. |
This FB can be instantiated multiple times for different counting tasks, just like a built-in counter. It’s a clean, scalable solution for PLCs that lack native counter functions.
Handling Bit-to-Word Conversion Without MOV K4M10
Another common challenge is converting a group of bits into a word (16-bit integer). In Mitsubishi PLCs, the MOV K4M10 D200 instruction takes 16 consecutive bits starting at M10 and packs them into data register D200. If your PLC doesn’t support this syntax, you can achieve the same result using a loop or a series of bit-test and set instructions. A function block can also be created for this purpose, using a FOR loop to iterate through 16 bits and build the word value by shifting and adding. Alternatively, some PLCs offer a “BIT_TO_WORD” or “PACK” function in their library. Check the programming manual for advanced data manipulation instructions.
Pro Tip: When working with custom function blocks, always test edge cases: rapid successive triggers, reset during counting, and preset value changes. Simulate these scenarios to ensure robust operation in your industrial automation system.
Real-World Applications in Industrial Automation
Custom counter FBs are used in many industrial settings. For example, in a packaging line, a counter tracks the number of bottles filled. When the count reaches a preset (e.g., 12 for a carton), the FB triggers a downstream diverter. In conveyor systems, counters monitor product flow and detect jams if counts don’t increment within a time window. These blocks are also essential in electrical control panel design, where space and functionality must be balanced. By creating your own counters, you reduce dependency on specific PLC brands and increase code portability.
Best Practices for Custom Function Blocks
- Use descriptive tag names and comments to make the FB self-documenting.
- Encapsulate all counter logic inside the FB to avoid scattered INC instructions.
- Include an “enable” input to conditionally activate counting, saving scan time.
- Consider adding a “count down” option using DEC instruction for bidirectional counting.
- Validate the FB with a test routine before deploying to production.
Troubleshooting Common Issues
If your custom counter doesn’t behave as expected, check the following:
| Symptom | Possible Cause | Solution |
|---|---|---|
| Count increments multiple times per trigger | Missing one-shot logic | Ensure a rising edge detection is used before INC. |
| Count doesn’t reset | Reset input not wired or logic conflict | Verify reset rung executes unconditionally when reset is true. |
| Output doesn’t turn on at preset | Comparison operator error | Use ≥ instead of = to avoid missing the exact match due to scan timing. |
| Count value resets unexpectedly | Power cycle without retentive memory | Configure the count register as retentive in PLC settings. |
Expanding the Counter FB for Advanced Needs
Once you have a basic counter FB, you can extend it with additional features:
- Up/Down Counting: Add an input to select direction and use INC or DEC accordingly.
- High-Speed Counting: If the PLC supports high-speed inputs, integrate them for encoder-based counting.
- Batch Counting: Include a batch preset and a batch counter output for multi-stage processes.
- Data Logging: Store count values at specific events for traceability.
These enhancements make the FB suitable for complex automation control systems, from packaging machines to material handling.
Industry Insight: In modern industrial automation, the trend is toward standardized, reusable code modules. Custom function blocks for common tasks like counting, timing, and signal conversion reduce engineering time and improve reliability across projects. They are a cornerstone of efficient PLC programming.
Conclusion
Missing a dedicated counter instruction in your PLC is not a roadblock. By leveraging the INC instruction and creating a well-designed function block, you can implement robust counting functionality. This method also applies to other missing instructions, such as bit-to-word conversion. As you develop your own library of FBs, you’ll find that your PLC programming becomes faster, more consistent, and easier to troubleshoot. Whether you’re working on an electrical control panel or a full-scale automation system, these custom blocks are invaluable tools.
