Your purchase includes a free PDF copy of this book along with other exclusive benefits. Check the Free Benefits with Your Book section in the Preface to unlock them instantly and maximize your learning experience.

To get the most out of this chapter, a Windows computer and a working copy of an IEC 61131-3-compliant programming environment that supports OOP will be needed. For this book, the recommended programming system is CODESYS: https://us.store.codesys.com/.

This chapter will have multiple code examples. The code examples can be downloaded from GitHub by following the link: https://github.com/PacktPublishing/Mastering-PLC-Programming-Second-Edition.

The projects will utilize CODESYS and the book will assume you’re using that system. If you opt to use a different programming system, you will need to copy and paste the examples into the system of your choice. For the most part, an IEC 61131-3-compliant system should require minimal to no modifications to the source code; however, this will depend on which feature the system has adopted and how the vendor chose to implement the features. Regardless, the principles and techniques explored in this book...

Most advanced PLCs are IEC 61131-3-compliant to some degree, especially if they are PC-based, such as Beckhoff PLCs. IEC 61131-3 is a standard that essentially governs the programming environments that the PLC supports and the general functionality for the programming system. This means aspects such as syntax, semantics, typing, memory management, error handling, modularity, code organization, and so on should be mostly consistent between PLCs. The standard also governs the following programming languages:

• ST
• LL
• Sequential Function Chart (SFC), often called Sequential Flow Charts in slang
• Function Block Diagram (FBD)

The IEC 61131-3 standard is just that, a standard. IEC 61131-3 is not a programming language, PLC brand, or anything of the sort. The standard promotes uniformity across programming systems and ultimately promotes vendor neutrality.

Though the standard is vendor-neutral, you typically cannot...

The biggest hurdle to being a programming instructor is getting students to understand that the key to being a good engineer is not memorizing patterns or programming commands. To be successful as a developer, whether it be a developer for traditional apps or PLCs, lies in the ability to take established programming principles and apply them to any system. The key to mastering the material presented in this book is to approach it from a software engineering perspective. As you go through this book you will be tempted to think the material presented is only for CODESYS or even PLCs in general. However, this is a misnomer as the techniques explored in this book can be used with any OOP based language or system.

Programming software

To follow along with this book, an IEC 61131-3 programming environment that supports OOP will be required. The CODESYS environment will support most, if not all, of the IEC 61131-3 features and is free to download...

Errors can kill the execution of a program, which, in turn, can lead to injury or death in extreme cases. Exceptions occur when the PLC encounters a problem that it cannot handle at runtime. When one such error occurs, the PLC program will lock up or crash, and the PLC will typically need to be rebooted. On top of all that, if the condition that caused the error occurs again, the program will again crash and cause another lock up. In essence, the only safe way to handle the condition is to modify the code to ensure that the erroneous condition is handled gracefully.

Exception errors will not show up during the compilation process. Instead, exceptions occur when the program is running. Due to their nature, it is often difficult or impossible to fully predict when an exception will occur. To make matters worse, some exceptions can take very specific conditions to trigger, and, as a result, there might be long intervals between occurrences. To compound the issue, certain...

To understand a pointer, it is first necessary to understand the basics of how variables are stored in memory. For many PLC programmers, creating a variable or a tag is simply inputting a name and assigning it a data type; however, some mechanics take place under the hood. For starters, a variable is much more than just a name and a data type that holds a value. A variable is a dedicated memory block that the computer (in this case, the PLC) uses to hold a value of a specific type. The memory block is generally not human-readable; as such, the variable name is just a human-readable façade that makes accessing and manipulating the data in the memory block easy while adding context to the value.

Representing PLC memory

Figure 1.7 is a graphical representation of a PLC’s memory. It is a simplified way of conceptualizing how the PLC sees its memory addresses and the values that reside in those blocks:

Figure 1.7: A graphical representation...

State machines sound like a complex and scary concept. Depending on the context of the state machine, they can be complex; however, fundamentally, they aren’t. Fundamentally, a state machine can be defined as a structure where some type of input and a current state dictate some type of output state.

There are many types of state machines. In terms of automation, the most common is what’s known as a finite state machine (FSM). Essentially, an FSM is a state machine with a finite number of states. In a very basic sense, there are a few key components to an FSM:

• Finite number of states: A state can be thought of as a mode. In terms of automation, a mode can be something like a machine being in an on, off, or standby mode.
• Transitions: A transition can be thought of as the change from one state to another. For example, a machine going from on to off can be thought of as a transition.
• Input: An input can be some type of action or...

In the early days of artificial intelligence (AI), when computer and data science weren’t nearly as fleshed out, there was an AI technique called expert systems or expert machines. Essentially, these systems were a series of IF-THEN statements that, when executed correctly, could provide a level of expertise in a given system. Nowadays, these systems aren’t used as much in the traditional programming landscape due to the advances of actual AI systems, such as deep learning and the like. Nonetheless, expert systems can still have a great effect in the automation industry.

An expert system is a program or functionality of a program that is used to simulate human-like judgment and decision-making. Essentially, you can think of these systems as simulated experts for a domain. For example, suppose you have a cutting machine; you can use an expert system to automatically adjust the saw blade in relation to the consistency of the material.

Though traditional...

For our final project, we’re going to make a simple FSM that will control the state of a machine that is used to produce a certain number of parts. The machine will have multiple states, such as an on, off, and error state. To begin, let’s design our state machine!

State machine design

To begin, let’s jot out some pseudocode to get a basic feel for the general skeleton of the system:

Case state
1:
    Machine off
2:
    Production run (on)
    If error detected
        state = 3
3:
    Error state
    state = 1

As we can see, all we have are three states: on, off, and error. If an error is detected during a production run, the machine will transition to an error state. With the general logic in place, let’s implement the code.

Variables for the state machine

These are the variables that will be used for the state machine:

PROGRAM PLC_PRG
VAR
    machineState     : INT := 1;
    motorSpeedCutOff...

As a chapter challenge, integrate an expert system into the state machine. Add an extra state that will house a simple knowledge base that can determine whether the user inputted an invalid value when an error occurred. Be sure to add variables as needed to support the expert system!

This chapter has been an introduction to some of the more complex topics that you may encounter as a PLC programmer. We explored some advanced features of ST, such as pointers and error handling, as well as some complex topics such as state machines and expert systems. So far, we have only touched on the basics of what ST in the IEC 61131-3 standard can do. In the next chapter, we’re going to explore how to get the most out of variables!

1. What are three keywords that can be used with a TRY-CATCH block?
2. What is an expert system?
3. What is the difference between a fact and a rule?
4. What is a state machine transition?
5. What is an FSM?
6. What is the main purpose of a TRY-CATCH block?
7. What are some applications for an expert system?

Have a look at the following resources to further your knowledge:

• CODESYS pointer: https://content.helpme-codesys.com/en/CODESYS%20Development%20System/_cds_datatype_pointer.html
• CODESYS TRY-CATCH-FINALY: https://content.helpme-codesys.com/en/CODESYS%20Development%20System/_cds_operator_try_catch_finally_endtry.html