Evolving PLC Programming for Modern Automation

Image Source: mrdeeds/stock.adobe.com

By Michael Parks, PE, for Mouser Electronics

Published May 27, 2026

Modern industrial automation owes much of its flexibility to programmable logic controllers. Before programmable logic controllers (PLCs) appeared in the 1970s, factory control was dominated by hard-wired electromechanical relays, timers, and contactor systems that were robust but notoriously difficult to modify when production requirements changed. Since the advent of the PLC, automation technology has increasingly shifted from hardware to software-configurable features, and features once only dreamed of have become a reality.

History of PLC Programming

Early PLC programming techniques evolved from physically constrained, hardware-adjacent methods into more formalized software practices. Early PLCs of the 1970s were programmed directly on the factory floor using handheld keypads or dedicated terminals, where technicians entered numeric instructions and memory addresses that represented ladder logic derived from relay schematics (Figure 1).

Figure 1: An example of a handheld programmer for PLCs. Today, laptops are the most common tool for programming. (Source: Green Shoe Garage)

In the 1980s, improved microprocessors and portable programming consoles enabled offline editing, better diagnostics, and more expressive vendor-specific languages, while ladder logic remained dominant due to its familiarity to electricians. The 1990s marked a significant transition as personal computers replaced proprietary terminals and networking became common, enabling richer development environments and versioned program storage. This era also saw the introduction of the IEC 61131-3 standard, which formalized multiple PLC programming languages, including Ladder Diagram, Function Block Diagram, and Structured Text. The standard cemented PLC programming as a disciplined form of industrial software engineering rather than merely an electronic replacement for relays.

Programming Modern PLCs

Over the last decade, PLC programming has evolved from isolated machine control into software-defined, networked automation systems. Modern PLCs are developed using full-featured integrated development environments (IDEs) that support simulation, live debugging, reusable libraries, and symbolic tag-based development, with Structured Text gaining wider adoption for complex logic alongside traditional Ladder Diagrams. Ethernet-based industrial networking, standardized data models, and protocols such as Open Platform Communications Unified Architecture (OPC UA) have blurred the boundary between operational technology (OT) and information technology (IT), allowing PLCs to publish data directly to historians, manufacturing execution system (MES) platforms, and cloud services. The emergence of safety-certified controllers, motion-integrated PLCs, and soft PLCs running on industrial PCs has further expanded the scope of PLC programming, pushing it closer to embedded and real-time software engineering. Standards bodies such as the IEC continue to anchor these advances to familiar execution models and languages that preserve determinism, readability, and long-term maintainability.

At the same time, modern PLC architectures intentionally separate time-critical control from non-deterministic computing. Core control logic remains written in a small set of deterministic, domain-specific languages optimized for safety and predictability. However, higher-level functions such as networking, databases, visualization, analytics, and cloud integration are increasingly implemented using contemporary programming languages such as C++, C#, Python, or JavaScript, running on adjacent industrial PCs, edge devices, or soft-PLC runtimes. This split architecture reflects a deliberate trade-off: Real-time control remains straightforward and analyzable, while higher-level software is free to evolve at the pace of modern IT, enabling PLC-based systems to function as robust, data-aware components of larger cyber-physical platforms.

Pros and Cons of Modern Techniques

Industrial automation has changed significantly over the past decade. Where PLCs once operated as standalone, hard-wired controllers, they are now embedded within broader, software-rich automation ecosystems. Modern PLCs routinely coexist with industrial PCs, edge devices, cloud services, and enterprise IT systems, forming layered architectures that combine real-time control with data-centric computing. This shift enables new capabilities but introduces trade-offs that must be managed deliberately.

A major advantage of modern PLC architecture is the separation of concerns, specifically between real-time control and higher-level system functions. Time-critical control logic continues to execute in deterministic PLC runtimes using IEC 61131-3 languages, preserving predictability, safety certification, and long-term maintainability. In parallel, non-deterministic functions, including data logging, visualization, analytics, and cloud integration, are handled by companion systems such as industrial PCs, soft PLCs, or edge gateways. These systems typically run software written in C++, C#, Python, or JavaScript, allowing developers to use modern tools and libraries without introducing risk to the PLC scan cycle.

This architectural split improves scalability and integration. Ethernet networking and standardized protocols, such as OPC UA, enable PLCs to interface directly with MES platforms, historians, digital twins, and cloud services. Non-critical software can be updated independently of validated control logic, and machines that once produced limited signals now generate useful operational insight. As a result, PLCs have evolved from isolated controllers into integral components of larger cyber-physical systems.

Developer productivity benefits as well. Modern IDEs provide simulation, live debugging, symbolic naming, and reusable libraries, reducing development and commissioning time. Structured Text is increasingly used for complex logic, while IT-oriented developers can contribute using familiar languages without deep involvement in deterministic control design.

However, these gains come with costs. Layered architectures increase system complexity, requiring disciplined interface design, robust networking, and careful separation between real-time and non-real-time components. Reliability expectations are also challenged, as rapidly evolving IT software must coexist with PLC systems designed for decades-long stability. Increased connectivity further expands the cybersecurity attack surface, demanding greater operational maturity.

In short, modern techniques bring meaningful gains in capability and flexibility, but they also raise the bar for system architecture and engineering discipline. The most successful automation systems integrate modern software thoughtfully while preserving determinism and clarity at the core.

A Tale of Two Approaches

Using modern software, such as Python, with a PLC can mean very different things depending on the platform. The contrast between Schneider Electric’s Modicon M221 and Phoenix Contact’s PLCnext illustrates two distinct design philosophies.

With the Modicon M221 (Figure 2), Python is used alongside the PLC rather than within it. The M221 is a compact, traditional controller built around deterministic scan-cycle execution and IEC 61131-3 logic. Python runs on an adjacent industrial PC or edge device and communicates with the PLC using protocols such as Modbus Transmission Control Protocol (TCP) or EtherNet/IP. In this model, Python handles non-time-critical tasks like data logging, analytics, dashboards, and cloud integration, while the PLC remains focused on real-time control. This approach preserves a clear separation of responsibilities but requires explicit protocol mapping and coordination.

Figure 2: Schneider Electric’s Modicon M221 PLC. (Source: Mouser Electronics)

PLCnext (Figure 3) takes a converged approach. PLCnext controllers run a Linux-based operating system and are designed to host IEC 61131-3 logic alongside higher-level languages, such as Python, on the same device. Data exchange occurs through shared services or application programming interfaces (APIs) rather than external fieldbus protocols, reducing inter-device communication overhead and simplifying system architecture. This enables advanced use cases, including on-controller analytics and protocol translation, without additional hardware.

Figure 3: Phoenix Contact’s PLCnext development platform. (Source: Mouser Electronics)

The difference is architectural intent. The M221 emphasizes separation and predictability, aligning well with traditional validation and maintenance practices. PLCnext emphasizes convergence and flexibility, enabling faster development but requiring stronger discipline to protect real-time behavior.

Both approaches are valid. The right choice depends on whether a system prioritizes architectural clarity and separation or tighter integration and on-controller software flexibility.

Conclusion

PLCs’ development has never been stagnant, but their evolution has been defined as much by restraint as by innovation. While modern hardware, networking, and software techniques have dramatically expanded what automation systems can do, the core principles that made PLCs successful—determinism, clarity, and long-term reliability—remain largely unchanged. Today’s PLCs sit at the center of layered automation architectures, combining time-critical control logic with powerful, non-deterministic computing environments that extend their reach into data analytics, visualization, and cloud-connected systems.

For engineers and system designers, the challenge is no longer choosing between traditional and modern approaches but learning how to integrate them responsibly. The most effective automation systems preserve the simplicity and predictability of classic PLC control while selectively embracing modern tools where they add real value. In doing so, PLCs continue to serve not only as controllers but also as stable anchors in increasingly complex cyber-physical systems that quietly evolve while remaining true to the roles they were designed to play.