No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
A live static code analysis architecture for PLC software
Static code analysis techniques analyze programs by examining the source code without actually executing them. The main benefits lie in improving software quality by detecting potential defects and problematic code constructs in early development stages. Today, static code analysis is widely used and numerous tools are available for established programming languages like C/C++, Java, C# and others. However, in the domain of PLC programming, static code analysis tools are still rare. In this paper we present an approach and tool support for static code analysis of PLC programs. The paper discusses opportunities static code analysis can offer for PLC programming, it reviews techniques for static analysis, and it describes our tool that implements a rule-based analysis approach for IEC 61131-3 programs.
14.0 Service Infrastrukturen
Cyber-physische Systeme (CPS) besitzen hohe nicht-funktionale Anforderungen (NFA) in Bezug auf einen sicheren, fehlertoleranten, resilienten, effizienten, selbst-organisierenden und störungsfreien Betrieb. NFA sind daher notwendigerweise in der detaillierten Ausgestaltung und Spezifikation einer Service-Infrastruktur für CPS zu berücksichtigen – so auch auf dem Weg zu einem I4.0 Referenzmodell bzw. einer I4.0-Referenzarchitektur. Wie das sinnvoll geschehen kann, war bislang wenig Gegenstand der Forschung und Entwicklung. Klassische Referenzmodelle für Service-Architekturen aus der Informatik betrachten obige NFA bislang nicht. Ein erster Ansatz wird in der Industrial Internet Reference Architecture (IIRA) lediglich in Bezug auf die Informationssicherheit (security) gemacht. NFA werden überwiegend auf so abstrahiertem Niveau beschrieben, dass sie für die konkrete Spezifikation einer Service-Infrastruktur für CPS zu abstrakt sind, um wirklich nützli...
Static code analysis techniques are a well-established tool to improve the efficiency of software developers and for checking the correctness of safety-critical software components. However, their use is often limited to general purpose or 'mainstream' programming languages. For these languages, static code analysis has found its way into many integrated development environments and is available to a large number of software developers. In other domains, e. g., for the programming languages used to develop many industrial control applications, tools supporting sophisticated static code analysis techniques are rarely used. This paper reports on the experience of the authors while adapting static code analysis to a software development environment for engineering the control software of industrial process automation systems. The applicability of static code analysis for industrial controller code is demonstrated by a case study using a real-world control system.
We report on the behavior of developers working with a live coding environment, which provides information about a program's execution immediately after each change to the source code. The live coding environment we used shows information about each individual source code line, e.g., changed variable values or truth values of conditions. In comparison to developers working in a non-live environment, those working live found and fixed bugs they introduced significantly faster. Further, working live encouraged developers to switch between editing and debugging phases more frequently.
This paper presents an analysis to infer range and value-set information for programs operating on programmable logic controllers. Given a program, the algorithm gathers all possible values of all variables for all possible program executions using abstract simulation. The set of these values constitutes an over-approximation of the program behavior and can thus be used to directly detect potential misbehavior. Crucially for practical applications, this approach works automatically without preprocessing or manual intervention. The approach is implemented in the ARCADE.PLC framework and evaluated on a case study from industry.
Liveness in programming environments generally refers to the ability to modify a running program. Liveness is one form of a more general class of behaviors by a programming environment that provide information to programmers about what they are constructing. This paper gives a brief historical perspective on liveness and proposes an extension of a hierarchy given in 1990, to now account for even more powerful execution-oriented tools for programmers. In addition, while liveness concerns the timeliness of execution feedback, considering a broader array of forms of feedback is helpful both in better understanding liveness and in designing ever more powerful development tools.
Program slicing is a decomposition technique that slides program components not relevant to a chosen computation, referred to as a slicing criterion. The remaining components form an executable program called a slice that computes a projection of the original programpsilas semantics. Using examples coupled with fundamental principles, a tutorial introduction to program slicing is presented. Then applications of program slicing are surveyed, ranging from its first use as a debugging technique to current applications in property verification using finite state models. Finally, a summary of research challenges for the slicing community is discussed.
Visual languages have been developed to help new programmers express algorithms easily. They also help to make experienced programmers more productive by simplifying the organization of a program through the use of visual representations. However, visual languages have not reached their full potential because of several problems including the following: difficulty of producing visual representations for the more abstract computing constructs; the lack of adequate computing power to update the visual representations in response to user actions; the immaturity of the subfield of visual programming and need for additional breakthroughs and standardization of existing mechanisms.Visualization of Vision Algorithms (VIVA) is a proposed visual language for image processing. Its main purpose is to serve as an effective teaching tool for students of image processing. Its design also takes account of several secondary goals, including the completion of a software platform for research in human/image interaction, the creation of a vehicle for studying algorithms and architectures for parallel image processing, and the establishment of a presentation medium for image-processing algorithms.
Abstract interpretation is a formal method that enables the static determination (i.e. at compile-time) of the dynamic properties (i.e. at run-time) of programs. We present an abstract interpretation-based method, called abstract debugging, which enables the static and formal debugging of programs, prior to their execution, by finding the origin of potential bugs as well as necessary conditions for these bugs not to occur at run-time. We show how invariant assertions and intermittent assertions, such as termination, can be used to formally debug programs. Finally, we show how abstract debugging can be effectively and efficiently applied to higher-order imperative programs with exceptions and jumps to non-local labels, and present the Syntox system that enables the abstract debugging of the Pascal language by the determination of the range of the scalar variables of programs.
- Din En
IEC, DIN EN 61131-3 Speicherprogrammierbare Steuerungen-Teil 3:
Programmiersprachen, Berlin, 2003.
- Din Iec
- En
IEC, DIN EN 61131-3 Speicherprogrammierbare Steuerungen -Teil 3:
Programmiersprachen, Berlin, 2003.