Henning Dierks

PLC-Automata: A New Class of Implementable Real-Time Automata

We introduce a new class of automata which are tailored for dealing with real-time properties modelling the behaviour of Programmable Logic Controllers (PLC) that are often used in practice to solve controlling problems. A semantics in an appropriate temporal logic (Duration Calculus) is given and an implementation schema is presented in a programming language for PLCs that fits the semantics. Finally, a case study shows the suitability of this approach.

PLC-automata: a new class of implementable real-time automata

We introduce PLC-automata as a new class of automata which are tailored to deal with real-time properties of programmable logic controllers (PLCs). These devices are often used in industrial practice to solve controlling problems. Nevertheless, PLC-automata are not restricted to PLCs, but can be seen as a model for all polling systems. A semantics in an appropriate real-time temporal logic (duration calculus) is given and an implementation schema that fits the semantics is presented in a programming language for PLCs. A case study is used to demonstrate the suitability of this approach. We define several parallel composition operators, and present an alternative semantics in terms of timed automata for which model-checkers are available.

Comparing model checking and logical reasoning for real-time systems

Abstract.We apply both model checking and logical reasoning to a real-time protocol for mutual exclusion. To this end we employ PLC-Automata, an abstract notion of programs for real-time systems. A logic-based semantics in terms of Duration Calculus is used to verify the correctness of the protocol by logical reasoning. An alternative but consistent operational semantics in terms of Timed Automata is used to verify the correctness by model checkers. Since model checking of the full model does not terminate in all cases within an acceptable time we examine abstractions and their influence on model-checking performance. We present two abstraction methods that can be applied successfully for the protocol presented.

Operational and Logical Semantics for Polling Real-Time Systems

PLC-Automata are a class of real-time automata suitable to describe the behavior of polling real-time systems. PLC-Automata can be compiled to source code for PLCs, a hardware widely used in industry to control processes. Also, PLC-Automata have been equipped with a logical and operational semantics, using Duration Calculus (DC) and Timed Automata (TA), respectively.

Specification and Verification of Polling Real-Time Systems

Formal methods for real-time systems are an important topic of contemporary research. The aim is to cope with the additional complexity of “time” in specification and verification. In [Die99a] we present an approach to the correct design of real-time programs implemented on “Programmable Logic Controllers” (PLCs). This hardware executes repeatedly an application program whereas each cycle has an upper time bound. The central device in our approach is the notion of “PLC-Automaton” which provides an abstract view on PLC programs. For PLC-Automata the following results are presented in [Die99a]: 1. It is possible to generate PLC source code from a PLC-Automaton. Also constraints on both the speed of the PLC and on the accuracy of time measurement are derived. 2. A logical semantics in terms of Duration Calculus is developed. Since this semantics considers the cyclic behaviour, computation speed, and timer tolerances a realistic model of the real-world behaviour is given. 3. Several ways to compose PLC-Automata are defined and described semantically. 4. An alternative operational semantics in terms of Timed Automata is given. It is provably consistent with the Duration Calculus semantics. Hence, model-checking PLC-Automata is possible due to this semantics. Moreover, we examine techniques for building abstractions of these Timed Automata models. 5. A formal synthesis procedure for “Implementables”, a sublanguage of Duration Calculus, is derived that produces a PLC-Automaton implementing the Implementables-specification if and only if there exists an implementing PLC-Automaton.

MOBY/PLC - Graphical Development of PLC-Automata

Moby/plc is a graphical design tool for PLC-Automata, a special class of hierarchical real-time automata suitable for the description of distributed real-time systems that are implementable on a widely used hardware platform, so-called Programmable Logic Controllers (PLCs). In this paper we sketch the modelling language in use and some features of Moby/plc, like several validation methods and code generation.

Tool-supported hierarchical design of distributed real-time systems

The authors demonstrate the usage of a formal description technique for real-time systems called PLC-Automaton by applying this method to a real-world case study. To this end they use the tool which was built for PLC-Automata. This tool, called MOBY/PLC, provides simulation and verification methods to validate a design. Furthermore, the design can be translated into executable source code for real machines.

Decomposing Real-Time Specifications

In this paper we show that every real-time system specified in a certain subset of Duration Calculus [24] can be decomposed into an untimed system communicating with suitable timers. Both asynchronous and synchronous communication are considered.

Constructing Test Automata from Graphical Real-Time Requirements

A semantics for a graphical specification language of real-time properties (Constraint Diagrams) is presented. The new semantics is given in terms of Timed Automata. A model in terms of Timed Automata satisfies the property given by a Constraint Diagram if the model in parallel composition with the semantics of the Constraint Diagram can reach a certain state. This kind of question can be checked by all model-checkers for Timed Automata. A prototype of a tool is presented that automatically translates an appropriate Constraint Diagram into the input language of the tool Uppaal.

The Production Cell: A Verified Real-Time System

This paper applies and refines the ProCoS approach to transformational design of real-time systems to a benchmark case study, the Karlsruhe production cell [10, 9]. We start by formalizing the informal requirements of [10, 9] in Duration Calculus and end with a distributed controller architecture where all components are specified in the program specification language SLtime [18]. Novel is the full treatment of hybrid system components in a parametric and thus reusable way.