Zeeshan E. Bhatti

Observer based verification of IEC 61499 function blocks

IEC 61499 is an international standard for designing Industrial Process Control Systems using artefacts such as Function Blocks and Execution Control Charts. The existing approaches towards formal verification of function blocks lack the natural expression for specifying the system properties. We suggest an approach for performing formal verification of IEC 61499 designs using observers expressed as function blocks. This method provides the IEC 61499 designer with an intuitive way of expressing system properties and also makes the verification result easier to map to the original design. We have implemented two different algorithms, a tableau based CTL model checker and a reachability analyzer, to support the verification of observers. Experimental evaluation over a range of benchmarks have shown better performance as compared to Esterel based verification in terms of computation time.

Unified management of control flow and data mismatches in web service composition

The two main aspects of the web service composition problem are control flow and data mismatches. Several approaches have been reported in the literature to tackle the former; while the latter, and equally relevant aspect for the correct compositional behavior, has either been ignored or addressed to a very limited extent. This paper describes a formal approach based on model checking, that guarantees the correct interaction of services in a composition by managing control flow and resolving data mismatches at semantic, syntactic and structural levels, in a unified manner. A tableau based algorithm is used to generate and explore compositions in a goal-directed fashion, that proves or disproves the existence of a service orchestrator. Successful synthesis of the orchestrator confirms that the required functionality is realizable. Data models to detect and resolve data mismatches are generated using WSDL documents and regular expressions. Experimental results provide strong testimony that the approach can be effectively applied in a practical setting.

Model-Driven Design Using IEC 61499

This book describes a novel approach for the design of embedded systems and industrial automation systems, using a unified model-driven approach that is applicable in both domains. The authors illustrate their methodology, using the IEC 61499 standard as the main vehicle for specification, verification, static timing analysis and automated code synthesis. The well-known synchronous approach is used as the main vehicle for defining an unambiguous semantics that ensures determinism and deadlock freedom. The proposed approach also ensures very efficient implementations either on small-scale embedded devices or on industry-scale programmable automation controllers (PACs). It can be used for both centralized and distributed implementations. Significantly, the proposed approach can be used without the need for any run-time support. This approach, for the first time, blurs the gap between embedded systems and automation systems and can be applied in wide-ranging applications in automotive, robotics, and industrial control systems. Several realistic examples are used to demonstrate for readers how the methodology can enable them to reduce the time-to-market, while improving the design quality and productivity.

A model-driven approach with synchronous semantics for developing hard real-time WSNs

We propose a model-driven approach for designing Wireless Sensor Network (WSN) applications, specifically for systems where hard real-time requirements must be satisfied. Traditionally, developing such systems presents difficulties in ensuring time and timing accuracy due to unpredictable computation time, ambiguities in program concurrency, and behavioural inconsistency between model and implementation. However, in contrast, the models in our approach are fully time-predictable by means of a logical time interval called a tick, while concurrency is automatically handled by the design semantics in a timing guaranteed manner. Meanwhile, the model-driven aspect of automatic code generation guarantees the behavioural consistency between model and implementation. We achieve our approach by using IEC 61499 function blocks and synchronous execution for syntax and semantics respectively. In this paper, we design a time-triggered protocol and a distributed motor synchronization as the network and application layers respectively. Then, we model the overall system for validation by performing composition of such layers. Furthermore, we explain how the logical time tick can be realized during the implementation in a way that the real-time requirement can be satisfied. Finally, the simulation and implementation results demonstrate the effectiveness of our approach.

Unified Functional Safety Assessment of Industrial Automation Systems

The IEC 61499 standard enables the model-based design of complex industrial automation systems, in which a model of the controlled physical processes called a plant, is codeveloped with the controller. However, the existing design flow does not address functional safety issues, which include limiting risk to acceptable levels. Standards like IEC 61508 provide safety guidelines for measuring and managing risk to acceptable ranges using quantitative or probabilistic methods for hardware, and qualitative or systematic analysis techniques for software. Such analyses are inadequate in situations where safety depends on both hardware and software. This paper proposes a unifying model-based approach for the quantitative and qualitative analysis of IEC 61499 designs. The approach combines Markov analysis and model checking to estimate quantified risk and is more expressive than traditional analyses like reliability block diagrams. At design level, unified safety requirements are captured using safety blocks, which is an extension of the IEC 61499 basic blocks. The PRISM model checker is used to analyze the system, based on a sound conversion of IEC 61499 designs into PRISM models. A tool-chain enabling the proposed approach shows encouraging benchmarking results confirming the feasibility of unified analysis.

Combining IEC 61499 model-based design with component-based architecture for robotics

The model-driven approach is an increasingly popular trend in software design. It provides many benefits in terms of system design, reusability, and automatic code generation. In the industrial automation domain, the IEC 61499 standard is a recent initiative that adopts this approach. It offers an open, platform-independent framework for designing distributed control systems, whereby the interface and behaviour of a component is described using a function block. On the other hand, in the robotics domain, the Robotic Technology Component specification proposes a framework that allows software components to be easily integrated in a robotic system. The focus of that specification is not so much on the definition of each components internal behaviour, but rather on the management and interaction of those components. The combination of both these standards offers a comprehensive solution for designing robotic software components in a model-driven approach. This paper describes a tool-chain for doing so, and illustrates its viability through an example.

Introduction to Synchronous Programming Using Esterel

This chapter describes the synchronous approach for designing embedded and automation systems. We present the core concepts of synchronous programming using a well-known synchronous language called Esterel. Esterel consists of a set of ”pure Esterel” statements for describing control flow. Data handling is performed using calls to C functions. We present the syntax and intuitive semantics of pure Esterel using a set of examples, such as a 4-bit counter and the user interface for a MP3 player. Subsequently, we present the Esterel to C interface using the pedagogic example of a lift-controller. This chapter introduces the key concepts necessary for the understanding of subsequent chapters.

IEC 61499 in a Nutshell

The IEC 61499 standard provides definition of various structures, such as systems, devices, resources, and various function block types, which allow for a component-oriented design of a program. This design approach resembles the famous object-oriented design paradigm, where the domain objects, e.g. sensors, actuators and devices, are modelled along with the automation logic. The execution of these structures depends on the adopted execution semantics, which determine the protocol of accepting inputs, processing signals, and generating outputs. In this chapter, we offer a brief introduction to some of the structures defined by the IEC 61499 standard and the various execution semantics that are commonly employed for their execution. The discussion on the advantages and disadvantages of each of the presented semantics motivates the adoption of the synchronous execution semantics proposed in this book, and described in detail in Chap. 4.

Model-driven development of industrial embedded systems: Challenges faced and lessons learnt

The strict requirements of embedded control software, in the absence of a formal approach, necessitates ad-hoc optimisations and coding decisions in the “C” language. Model driven development (MDD) is a proposed methodology for alleviating problems inherent in this method. We propose an IEC 61499 model based approach for the reengineering of existing or legacy industrial embedded systems. Experimental evidence and hands-on experience is used to illustrate the challenges faced by adopting such an approach; primarily, the lacuna that exists between current standards and industry practices. Several syntactic enhancements based on a layered approach are proposed to address these concerns.

Efficient Code Synthesis from Function Blocks

This chapter presents techniques for automatically generating code from IEC 61499 function blocks. While software synthesis from function blocks is in itself not new, the generation of efficient code from it is challenging. This is particularly so for the synthesis of distributed programs, as most existing techniques rely on features of a specific run-time environment to facilitate this. Instead of a run-time environment, this chapter proposes a globally asynchronous locally synchronous (GALS) model to implement distributed function block systems. This model provides an abstract way to view communication between function blocks without implying any particular implementation yet. This abstraction can then be subsequently refined to obtain various implementations with different trade-offs. This is done using an approach that is fully compatible with the standard’s notion of communication function blocks, which abstract underlying communication mechanisms from the application. For centralized programs, the synthesized code may be fully synchronous, which results in very efficient deterministic programs.