How do you feel about this article? Help us to provide better content for you.
Thank you! Your feedback has been received.
There was a problem submitting your feedback, please try again later.
What do you think of this article?
As we race into the 2020s, we are approaching an important milestone; it will soon be 100 years since the introduction of relay logic. It is significant because we can consider the appearance of relay logic to be the dawn of the automation age. If it were to arrive today, it would probably be referred to as 'disruptive technology'. But don't despair, because a century later there's a new disruptor in the industrial automation arena. Not the IoT, although that is significant, but open-source technology.
Admittedly, open source is not new, but it continues to shake things up. Wherever it goes, open-source technology is an agent for change, because it pokes a finger at the established way of doing things. Open source has the nerve to ask 'why?' whenever someone says, 'this is how we do things here'. Open-source technology is like the small child who points out that the King is actually naked.
Open source now has its sights set on changing industrial automation. More specifically, it is challenging the conventional thinking that applies to programmable logic controllers; the descendent of relay logic. Proprietary PLCs have shared rein over the kingdom of industrial automation for over 50 years, but Open Source is stripping them bare.
The impact of solid-state technology
As well as marking the beginning of automation, relay logic was also instrumental in the development of control technology in general. Those early devices were hard-wired, which led to the development of standardised approaches to their configuration; configuration protocols that evolved into programming languages.
Although the scripting languages used by PLC manufacturers are largely proprietary, the underlying programming languages are still based on Part 3 of the standard IEC 61131. They are directly relatable to the diagrams initially used to configure relay and ladder logic, and can be seen as a unique combination of logic diagram and high-level programming.
The development of solid-state technology meant that configuring relay logic turned into programming a microcontroller. Microprocessors are abstract devices that enable the modern age, often programmed through very high-level languages that are massively abstracted from the underlying technology. Microcontrollers, on the other hand, are much less abstract, representing the interface between hardware and software.
Because of this, it is microcontrollers (MCUs and not microprocessors that sit at the heart of modern PLCs today. The way we program MCUs is not that far removed from the way relay logic was configured. While it isn't that common, engineers may still use techniques such as Karnaugh Maps and Boolean logic to work out what an MCU needs to do. These days, the control algorithms implemented by MCUs are usually written in a high-level language such as C, but it isn't unheard of for engineers to revert back to a much lower level, such as assembly code, when necessary. Similarly, the languages used by PLCs are still closely linked to those early relay circuits, which were wired by hand using schematics developed by reducing the desired outcome to the simplest logical expression.
Thanks to MCUs, PLCs are much more sophisticated than relay logic. They can implement complex computational processes that work on data using multiple, concurrent execution paths. This is the great advantage of a program, running on a processing core that includes an ALU (arithmetic logic unit); it is able to evaluate more options before choosing the most appropriate one.
It is interesting that, right now, the IoT is going through something similar. The implementation of Artificial Intelligence at the network's edge is analogous to the way PLCs superseded relay logic. More intelligence, closer to the action, seems to be a recurring theme.
Another important milestone in the evolution of PLCs was passed when relays were replaced by solid-state switches. It was important because in terms of size, power and weight, solid-state switches offer significant advantages. It also enabled greater signal density in the same form factor. This, coupled with continued increases in processing performance, has led to a huge expansion in capabilities.
The Open-Source PLC
The way open-source is upsetting the PLC market is really quite comprehensive. It isn't suggesting that PLCs should standardise on a non-proprietary scripting language that can be implemented under a public licence, which is its usual modus operandi. It isn't suggesting that the hardware design should be open source, which is also one of its party tricks.
The way open-source is changing PLCs is by tearing up the idea of a PLC altogether and suggesting it should be based on something like the Raspberry Pi. There is a growing number of companies that have taken the Raspberry Pi and ruggedised it to make it applicable to an industrial environment.
Typically, this involves pairing a Raspberry Pi with one or more additional boards that provide the I/O and digital/analogue features of a conventional PLC. These additional boards would be designed to provide the isolation needed in an industrial environment, as well as the ability to withstand high voltages and currents. Through these extensions, the Raspberry Pi can be integrated, at least in hardware terms, into an industrial automation environment.
The software integration is another matter. Unlike PLCs, single-board computers like the Raspberry Pi aren't designed to be programmed using languages based on the IEC 61131-3 standard. They run Linux, or a derivative of Linux, which is an operating system best accessed through high-level programming languages such as C, C++ and Java, or using even higher levels of abstraction that work purely with mathematical expressions.
This is a long way from the bit-bashing environment of MCUs, which is where ladder logic really makes sense. But that only presents another opportunity for disruption. A good example here is PLCnext from a company called Phoenix Contact. This is an open programming environment based on the Linux operating system but targeting PLC applications. It does that by providing engineers with choices about how they configure their system, by using an IEC 61131-3 based language, or at a higher level, using IT technologies, including HTML.
This is fairly revolutionary when you think about it. This level of integration at the software layer is essential if open-source technology is going to make a real impact on industrial automation. We can't ignore the fact that any open-source solution is going to be running Linux, and we can't overlook the fact that Linux wasn't designed for industrial automation. A framework that brings those two worlds together is exactly what's needed to make it work.
But it doesn't stop there. Technology such as Raspberry Pi running open-source software may challenge the PLC manufacturers into thinking outside the proprietary box, but industrial PCs have been doing this for years. An industrial PC is often used alongside a conventional PLC, but they can also take their place at the edge, in certain situations.
Another framework called CDP Studio, which happens to play nicely with PLCnext, is very much positioned in this domain. It provides a way of creating systems based on real-time control hardware and making them industrial control and automation solutions. This isn't as simple as it might sound, because the main objective of any control system is reliability, and that typically means high levels of responsiveness.
It is hard to make anything more responsive than bare metal. Those early PLCs were as bare as it got, but each layer of software added has introduced complexity and latency. While the complexity can be abstracted away through software, the very act of doing that increases latency. This is the balancing act that all providers need to strike.
Open-source PLC solutions need to deliver the same reliability with no discernible increase in latency if they are to really challenge the status quo. Fast processors help in this respect, but as any PC users will know too well, fast processors have a way of being slowed down by lazy software.
How the IoT is changing everything, again
Just because open-source technology can be used for industrial automation, does that really mean it should be? The short answer to that is IoT.
The IoT is rapidly becoming the Internet of Everything. What that means is that (almost) anything and everything can now be part of the Internet. Data lives in everything and if we use data properly it can tell so much. This information needs to be mined and the IoT is the pickaxe.
In truth, the IoT is probably the reason why conventional PLCs are seen as ripe for disruption. It isn't their core functionality that is coming under fire, they will always be excellent at executing control functions. Where they may struggle is in turning the data that they work with into actionable insights that can be used by the wider network.
This is a recognition of the limitations of the underlying technology. MCUs are powerful but they are generally optimised for control algorithms. The interfaces to a PLC are not intended for large volumes of data. At their core, a PLC will be running a tight control loop, anything else is a distraction.
In the IoT age, this is not ideal. Moving to a powerful, low-cost single-board computer like the Raspberry Pi makes a lot of sense in this respect because it has much more processing performance than the average PLC needs.
But why stop there? The fact that data is all around us means we should probably capture as much of it as we can. In a traditional topology that would probably mean using multiple PLCs connected to even more sensors and actuators. This would very quickly turn into a complex system based on a star network topology, with increasing levels of latency. In short, it would create a new problem based on the same issue of scalability and responsiveness.
The solution to this could be to reimagine, again, what a PLC really is. The move towards open-source technology already demonstrates that the industry is willing to embrace change. The question now becomes, how much change?
By removing the premise that control needs to reside centrally, the issue of scalability becomes moot. Control, in the context of the IoT and Industrial IoT, is really everywhere. This is enabled by more powerful MCUs, operating at the very edge of the network and connected over reliable interfaces.
One of those interfaces could be Single Pair Ethernet (SPE). This is rapidly emerging in the industrial space as a unifying standard. Today, Ethernet is used in industrial applications, but it is often in the form of one of several ruggedised versions now available. Although technically running on the same standard, these industrial Ethernet alternatives are not completely compatible. The working group promoting SPE aims to challenge that fragmentation, with a single standard that can be universally adopted.
One of the other key features of SPE is its size. It has been specifically designed to be smaller, require less power and have a lower unit cost than conventional Ethernet. This means it can be added to smaller endpoints, such as smart sensors and smart actuators. It promotes a disintegrated approach to control and takes the concept of a PLC to an entirely new place.
Let's get cyber-physical
We can expect this change to lead somewhere and that destination will be a place where the Information Technology (IT) world is much closer to the Operational Technology (OT) domain. The systems that do this are commonly referred to as CPS, or Cyber-Physical Systems.
In a CPS, there really are no conventional boundaries. Where one system ends, another begins, creating a system of systems. The IoT is really a system of systems and, increasingly, some of those systems are cyber-physical.
By reimagining the PLC, the concept of using wide area cyber-physical systems becomes an exercise in applying control. It would be challenging to implement that level of interconnected control using conventional PLCs. Even open-source solutions and industrial PCs as we know them today might struggle to meet the challenge. But as we develop solutions that can embody more intelligence at the very edge of the network, it will happen.
In this vision of the near future, all technologies may have a role. The PLCs in use today will not become redundant overnight. The new pretenders to the throne will be influential but not universally appropriate. Even industrial PCs, which probably hold the greatest scope for self-development, will need to evolve.
And all this disruption, coming from the open-source community, will change the way we do everything, all over again.