Programmable Logic Controller Software Research Articles

CSP solver for Safe PLC Controller: Application to manufacturing systems

This paper presents an original approach of safe control synthesis for manufacturing systems controlled by Programmable Logic Controller (PLC) based on the use of a CSP (constraint satisfaction problem) solver. In this work, manufacturing systems are considered as Discrete Event Systems (DES) with logical Inputs (sensors) and logical Outputs (actuators). The proposed approach separates the functional control part from the safety control part. The methodology is based on the use of safety constraints in order to get from a CSP solver all the safe outputs vectors at each PLC scan time. The safe outputs vector is selected by choosing the one which minimizes the Hamming distance with the functional outputs vector. The approach is illustrated with a sorting boxes simulated process using the ITS PLC software from the Real Games Company (www.realgames.pt).

Applying Model Checking to Industrial-Sized PLC Programs

Programmable logic controllers (PLCs) are embedded computers widely used in industrial control systems. Ensuring that a PLC software complies with its specification is a challenging task. Formal verification has become a recommended practice to ensure the correctness of safety-critical software, but is still underused in industry due to the complexity of building and managing formal models of real applications. In this paper, we propose a general methodology to perform automated model checking of complex properties expressed in temporal logics [e.g., computation tree logic (CTL) and linear temporal logic (LTL)] on PLC programs. This methodology is based on an intermediate model (IM) meant to transform PLC programs written in various standard languages [structured text (ST), sequential function chart (SFC), etc.] to different modeling languages of verification tools. We present the syntax and semantics of the IM, and the transformation rules of the ST and SFC languages to the nuXmv model checker passing through the IM. Finally, two real cases studies of the European Organization for Nuclear Research (CERN) PLC programs, written mainly in the ST language, are presented to illustrate and validate the proposed approach.

A Model-Driven Approach on Object-Oriented PLC Programming for Manufacturing Systems with Regard to Usability

This paper presents the modular automation for reuse in manufacturing systems (modAT4rMS) approach to support the model-driven engineering (MDE) of object-oriented manufacturing automation software with regard to its usability and software modularity. With usability, we refer to the aspects' effectiveness, efficiency, and user acceptance as defined by ISO 9241-11. The modAT4rMS notations are based on selected features from the unified modeling language (UML) and the systems modeling language (SysML), and iteratively further developed by a series of empirical studies with industrial practitioners, as well as mechatronics trainees. With modAT4rMS, an MDE approach for programmable logic controller (PLC) programming was developed with the goal to facilitate modular object-oriented programming of PLC software by improving the representation of the relationships between the structure and behavior diagram types, and by reducing the level of abstraction in the structure model. modAT4rMS notations for PLC software structure and software behavior modeling are presented and illustrated with a modeling example using a modAT4rMS editor prototype. For the evaluation of the developed notations, the results from a study with 168 participants are presented, showing the benefits of this new approach in comparison with the classic procedural paradigm (IEC 61131-3) and the domain-specific UML profile (plcML) in regard to programming performance and usability aspects. Finally, the advantages and limitations of the approach are discussed, and an outlook for further development is given.

An overview of model checking practices on verification of PLC software

Programmable logic controllers (PLCs) are heavily used in industrial control systems, because of their high capacity of simultaneous input/output processing capabilities. Characteristically, PLC systems are used in mission critical systems, and PLC software needs to conform real-time constraints in order to work properly. Since PLC programming requires mastering low-level instructions or assembly like languages, an important step in PLC software production is modelling using a formal approach like Petri nets or automata. Afterward, PLC software is produced semiautomatically from the model and refined iteratively. Model checking, on the other hand, is a well-known software verification approach, where typically a set of timed properties are verified by exploring the transition system produced from the software model at hand. Naturally, model checking is applied in a variety of ways to verify the correctness of PLC-based software. In this paper, we provide a broad view about the difficulties that are encountered during the model checking process applied at the verification phase of PLC software production. We classify the approaches from two different perspectives: first, the model checking approach/tool used in the verification process, and second, the software model/source code and its transformation to model checker's specification language. In a nutshell, we have mainly examined SPIN, SMV, and UPPAAL-based model checking activities and model construction using Instruction Lists (and alike), Function Block Diagrams, and Petri nets/automata-based model construction activities. As a result of our studies, we provide a comparison among the studies in the literature regarding various aspects like their application areas, performance considerations, and model checking processes. Our survey can be used to provide guidance for the scholars and practitioners planning to integrate model checking to PLC-based software verification activities.

Control design pattern based on safety logical constraints for manufacturing systems: application to a palletizer

This paper presents an original approach for safe controller design for manufacturing systems controlled by PLC (Programmable Logic Controller). In this work, manufacturing systems are considered as Discrete Event Systems (DES) with logical Inputs (sensors) and logical Outputs (actuators). The proposed approach, which separates the functional control part from the safety control part, is easy to implement and ensures that the designed controller is safe. The methodology is based on the use of safety constraints in order to get a permissive safe controller which can be validated off line by model-checking. This controller is then constrained by functional constraints. The approach is illustrated with a palletizer simulated process using the ITS PLC software from the Real Games Company (www.realgames.pt). The control algorithm is presented and allows resulting in a safe control using a standard control design pattern, may be simpler than a conventional approach based on a complete specification in GRAFCET (IEC 60848) that does not distinguish the functional aspect from the safety aspect. This approach presents interesting perspectives like the management of several operating modes linked to a Manufacturing Execution System (MES) or the manual modes through Human-Machine Interfaces (HMI) or Supervisory Control and Data Acquisition (SCADA) systems.

Formal component-based modeling and synthesis for PLC systems

Programmable Logic Controllers (PLCs) are widely used in industry. PLC systems are reactive systems which run cyclically. In each cycle, the system state is checked and the program is executed once to determine the system behavior for a single cycle. Development of PLC systems conventionally follows the V-model, but increasing demand for efficiency and reliability requires a new rigorous and rapid design flow. In this paper, we propose a component-based formal modeling and synthesis method for cyclic execution platforms and apply it to PLC. Our method consists of three main phases: modeling, verification and code synthesis. In the modeling phase, the BIP (Behavior–Interaction–Priority) framework which is flexible and expressive is used as the modeling language. Real-time behavior, which is intensely concerned in PLC systems, can be modeled as well. In the verification phase, the system model is translated to timed automata and checked by Uppaal. Verification helps to ensure correctness of the model and further increases reliability of the implementation. In the code synthesis phase, the software part of the system model is extracted and synthesized to cyclic code. Although the PLC software runs cyclically, the software model is not necessarily given in a cyclic manner. We propose an algorithm which can generate high-performance cyclic code from a model which describes the business work-flow. This feature significantly simplifies program development. A set of tools is implemented to support our design flow and they are applied to an industrial case study for a PLC system that controls dozens of physical devices in a huge palace.

Control synthesis based on logical constraints for safe manufacturing systems

Abstract This paper presents an original approach of safe control synthesis of manufacturing systems. This approach is based on the use of a logic filter (placed at the end of PLC (Programmable Logic Controller)) robust to control errors, and formally validated using a model checker. The proposed approach, which separates the functional control part from the safety control part, is simple to implement and ensures that the designed controller is safe. The methodology is based on the use of safety constraints coming from the filter in order to get the most permissive safe controller. This controller is then constrained by functional constraints. The approach is illustrated by using an example of sorting boxes simulated using the ITS PLC software from the Real Games company ( www.realgames.pt ). The control algorithm is presented and allows to result in a safe control, may be simpler than a conventional approach based on a specification in GRAFCET (IEC 60848), that does not distinguish the functional aspect from the safety aspect. This approach involves a new way to see the control of manufacturing systems and presents interesting perspectives like the management of several operating modes.

Automated PLC Software Testing using adapted UML Sequence Diagrams

Current production plants are highly customizable and flexible in their processes. This flexibility is mainly realized by software. It causes an increasing complexity of control software components and the need of new methods for comprehensive and automated testing approaches to ensure a requested level of quality at high efficiency. A survey among mechanical engineering companies of the industries aerospace, automotive and machine/plant automation was conducted. Aspects of requirements engineering, testing, simulation, processes, tools, etc. were addressed to reveal research demands of PLC (Programmable Logic Controller) control software development in machine/plant automation. A system architecture embedding UML sequence diagrams for testing is proposed. We further contribute transformation rules of semantically adapted UML sequence diagrams to the cyclic execution logic of PLCs for reactive systems. The approach can be applied to any IEC 61131-3 programming language of the automation control software. A prototypical realization shows proof of concept and reveals the potential for future work.

A Transformation Method between PLC Ladder Diagrams and Instruction Lists Using Recursive and Stack Algorithms

The method of transforming a ladder diagram (LD) and an instruction list (IL) of PLC (Programmable Logic Controller) to each other is investigated in this paper. Firstly, ladder-step is adopted on transforming LD into IL. Ladder-step is divided series or parallel by using recursive algorithm, and then complicated ladder-step can be divided into several simple ladder-steps which can be converted to IL easily. When obtaining simple ladder-steps’ IL, combining them together to get final IL program of complicated LD program. Secondly, on transforming IL into LD, stack algorithm contributes a lot. Scanning IL to generate LD of each instruction block, and then pushing them into stack. Combine LDs in the stack by operating instruction, and then IL is transformed into LD successfully. Finally, in the last part of this paper, we show our PLC software and lower position machine. In addition, this transforming algorithm has already applied in PLC software successfully.

Safe control synthesis based on Boolean constraints for manufacturing systems

This paper presents an original approach of safe control synthesis of manufacturing systems. This is an extension of the work that CReSTIC has led for several years on the definition and design of a logic filter (placed into a Programmable Logic Controller (PLC)) robust to control errors, and formally verified using a model checker. The proposed approach, which separates the functional control part from the safety control part, is simple to implement and ensures that the designed controller is safe. The methodology is based on the use of safety constraints coming from the filter in order to get the most permissive safe controller. This controller is then constrained by functional constraints. The approach is illustrated by using an example of sorting boxes simulated using the ITS PLC software from the Real Games company (www.realgames.pt). The control algorithm is presented and allows to result in a safe control, may be simpler than a conventional approach based on a specification in GRAFCET (IEC 60848), that does not distinguish the functional aspect from the safety aspect. This approach presents interesting perspectives like the management of several operating modes.

A New Approach : Software Development And Validation

For safety and effectiveness, the U.S. Food and Drug Administration (FDA) requires that software must be validated in the medical device industry. The software includes programs that are embedded in instruments and used in production/manufacturing process control, in which programmable logic controllers (PLCs) are widely used. The development and validation of a PLC program generally involves establishing software design (SD) structure, defining software requirements specification (SRS), conducting hazard analysis (HA), coding, and testing. The tasks are best accomplished through team efforts, with members taking the lead in activities suited to their skills within an organization; for example, SRS from the operation and the quality assurance (QA) departments; HA from emergency, health and safety (EHS); and coding from engineering. An integrated approach to these tasks would help a software project manager coordinate the team efforts effectively. This article describes an integrated approach to software development and validation in PLC programming. In this approach, the software development and validation start by establishing a normalized SD structure. This normalized structure is then incorporated into a traceability matrix (TM) of the SRS, into modules of program, and into test logs—such that every item defined in SRS or HA is registered in the normalized SRS TM table, coded in the normalized modules, tested, and documented in the normalized test logs. As the software system has a normalized structure, it becomes easy for different team members to define, review, code, test, document, and approve the relevant tasks within the software development and validation lifecycle.

An FPGA implementation of hard‐wired sequence control system based on PLC software

AbstractAlthough a programmable logic controller (PLC) has been widely adopted for the sequence control of industrial machinery, its performance does not always satisfy the recent requirements in large and highly responsive systems. With the state‐of‐the‐art field programmable gate array (FPGA) technology, it is possible to implement a control program with hard‐wired logic for higher response and reduced implementation cost/space. This approach is also worthwhile for transmigration of legacy PLC software into forthcoming FPGA‐based control hardware. This study presents a systematic method to implement a hard‐wired sequence control from PLC software. PLC instructions are converted into VHDL codes, and then implemented as logic circuit with various peripheral functions. Productive PLC programs were examined with Mitsubishi Electric FX2N PLC and Altera Stratix II FPGA, and were shown to fit into a common FPGA chip. A straightforward Sequential design was estimated to be 184 times faster than PLC, while a performance‐oriented Flat design was estimated to be 44 times faster than Sequential design (i.e., 8050 times faster than PLC). A practical perfect layer winder system was actually built and successfully operated with our FPGA control board, whose logic design was implemented with our tools. © 2011 Institute of Electrical Engineers of Japan. Published by John Wiley & Sons, Inc.

Domain specific model-based development of software for programmable logic controllers

Procedural process control is responsible for coordination of control units that perform basic control in a typical industrial control system. Basic control, in turn, performs actions necessary for maintaining a desired state of process variables and equipment. Software in the domain of procedural process control consists of modules responsible for management of startup and shutdown sequences, exception handling and module communication. In this work we present the domain specific modeling language (DSL) ProcGraph together with its corresponding code generation tool that was designed for the development of software in the domain of procedural process control systems. The advantage of using a domain specific language is that not only the programmers, but also domain experts are able to understand and modify the code. The DSL code is self-documenting, as it is expressed in the idiom of the problem domain. In the article we present a formal description of the ProcGraph language. Furthermore, we describe how the formal model is used in the implementation of the automatic IEC 1131-3 code generator.

The Application of PLC in the Auto-control System of Chemical Makeup Water Treatment of Boiler

With the deepening of China modernization course, the application of Programmable Logic Controller (PLC) is used more and more abroad in China. This article adopted the Quantum PLC and iFix industrial configuration software to study the application of PLC in the auto-control system of chemical makeup water treatment of boiler.

An investigation into programmable logic controller software design techniques in the automotive industry

PurposeThis paper aims to describe the results of an investigation into the techniques used to design factory control systems in the body‐in‐white section of car‐manufacturing plants in Germany, the UK and the USA.Design/methodology/approachResearch was conducted through a set of semi‐structured interviews with the individuals responsible for planning control system architectures in a number of companies world‐wide.FindingsThe challenges faced by the users of industrial control systems, such as the need to conduct changes quickly, accurately and without errors, are identified. Each organisation participating in this study was seen to use a company‐specific standard to bring commonality to systems and to improve the ease of developing, maintaining and modifying their control systems. Similar software structures were seen to be in use in many of the companies participating in this survey, though in some cases differing attitudes to the use of the same tools were observed.Practical implicationsThis work captures, documents and reviews industrial practice in a structured manner, providing an insight into the factors affecting the selection of control system technology by industrial users, and serves as a starting‐point for researchers wishing to investigate the relative importance to industrial practitioners.Originality/valueExisting work on industrial programming practice is extended by detailing specific software structures used in manufacturing operations in the car industry.

Software Tools for the Lifecycle Support of Safety Instrumented Systems

Since the publication of IEC 61508 (1) and IEC 61511 (2) there has been a steady increase in the number of PC based software tools developed to aid compliance. These come with a wide range of both capability and price, but carefully selected tools are considered the most appropriate way forward for ensuring lifecycle support of safety instrumented systems (SIS). Software tools are not just the realm of the design engineer, and this paper draws on experiences to demonstrate the benefits that can be realised by SIS engineering practitioners and end users. This paper will also discuss configuration aids for programmable logic controllers (PLC) but it will not cover PLC software or computer aided design (CAD) software. The range of available tools Tools are now available to support all phases of the lifecycle and it is important to note that the phases that usually attract the most focus range from Hazard and Operability (HAZOP) through to SIS design, but these only represent 25% of the complete lifecycle. The remaining 75% of the lifecycle phases, as shown in Figure 1, need just as much care and consideration for achieving compliance.

A Web-based programmable logic controller laboratory for manufacturing engineering education

This study presents the design and development of a Web-based programmable logic controller (PLC) system architecture that supports “hands-on” laboratory exercises in automated manufacturing systems control area for distance education. The system architecture allows remote users to access and control a PLC-based table-top manufacturing system via the Internet. A Web site has been designed and developed that facilitates interactivity and supports PLC programming and control. The architecture has been tested and implemented in the course Emgt 334 Computer Integrated Manufacturing Systems at the Integrated Systems Facility (ISF) in the Engineering Management Department at the University of Missouri-Rolla during Fall 2001. This study shows that software tools available in the market can be integrated to develop a fairly complex, yet effective, learning environment for distance education. The architecture presented in this paper is not dependent on specific PLC hardware or software configuration, it represents a generic infrastructure.

Translation and Optimization in the Verification of Real-Time Systems

Compilation or translation is not only an issue at the level of program but also at the level of specification. This talk considers the design of real-time software for Programmable Logic Controllers (PLCs) and discusses questions of correctness and optimization for translations between different semantic models. The need for such translations arises in order to bridge the gap between conceptually clear models on the one hand and computationally feasible models on the other hand.To exemplify this, the talk considers so-called Constraint Diagrams as formalizations of behavioural requirements and so-called PLC-Automata as design specifications. Both Constraint Diagrams and PLC-Automata are given a formal semantics in the Duration Calculus, a logic for real-time systems. To enable an automatic verification (model-checking) of designs against requirements, translations of Constraint Diagrams and PLC-Automata into Timed Automata are presented. Semantic correctness and optimization of these translations are discussed.The concepts presented in the talk are implemented in a tool called Moby-RT that besides the above verification facilities also offers a compiler for PLC code generation.

Automatic PLC software generator with a natural interface

This paper presents an object-oriented textual language designed to specify programmable logic controller software. This methodology, called OOST, allows users to specify the control logic in a natural manner, using a collection of objects that represent machines and other devices within a manufacturing system. The object-oriented specification technique may be used during the whole control software life cycle, and could be considered as a requirement definition language or an implementation one. An automatic PLC program generation system that uses descriptions written in OOST is also presented. A brief literature review is presented and the implementation details are discussed. The final part presents some future improvements and a few remarks.

An approach for developing domain specific CASE tools and its application to manufacturing process control

An investigation into the development and evaluation of a domain specific computer aided software engineering (CASE) tool, known as a methodology companion, is described. A development methodology for designing domain specific CASE tools supporting model-based analysis and automatic code generation is described. These ideas are used to produce a prototype methodology companion designed to assist the task of developing control software for programmable logic controllers (PLCs) in batch process manufacturing. The CASE tool is domain specific to the industry and organization described, and supports specification, analysis, simulation, report generation, and code generation of the manufacturing control steps. The tool is then evaluated in an industrial setting to determine its overall potential and limitations and the impact it will have on the domain.