Using java language for control algorithms

constrained resources devices used often in embedded systems are normally programmed using languages considered of low level. This has important implications in program development and maintenance. In fact, the code becomes less legible and the memory management in not an easy task. This problem can be overcome if the use of a high level language with garbage collector mechanism is considered. However, it is often a belief that from these high level languages results slowly programs, and so, they are unsuitable for embedded applications. In this paper this problem is addressed to show the applicability of Java to develop programs for constrained resources devices. An example of a control system for temperature control is presented to illustrate the advantages of the approach

Object Oriented Automation Systems

This master's thesis is about the implementation and evaluation of a small object-oriented automation system. By using a realtime Java VM from Jamaica, a sheet feeding magazine from the machine Tetra Aptiva Aseptic has been controlled. The expectations included to achieve more structured and safer programming, better documentation through UML and to separate application developers from developers of basic functionality. The work has involved to understand the existing control program, to design an object oriented model in Java and to run it on a test rack. The system worked fine, and most expectations were fulfilled. The performance measurements indicated that the Java was fast but also had a slightly larger jitter

Hard real-time Java virtual machine for Space applications

International audienceThe AERO ($UFKLWHFWXUH IRU (QKDQFHG 5HSURJUDPPDELOLW\ DQG 2SHUDELOLW\) is an ESA project with the objectives to investigate on a real-time Java virtual machine for ERC32 processor. Special attention was put on the garbage collection mechanism and deterministic execution model. The project have first investigate existing virtual machine to choose a potential candidate that will be customized, are then investigates the definition of requirements concerning a real-time interpreter in on-board systems. The second phase of the project was dedicated to the definition of software functions of the real-time Java virtual machine and to their implementation and assessment through validation tests. The resulting application is the AERO-JVM

Safe programming Languages for ABB Automation System 800xA

More than 90 % of all computers are embedded in different types of systems, for example mobile phones and industrial robots. Some of these systems are real-time systems; they have to produce their output within certain time constraints. They can also be safety critical; if something goes wrong, there is a risk that a great deal of damage is caused. Industrial Extended Automation System 800xA, developed by ABB, is a realtime control system intended for industrial use within a wide variety of applications where a certain focus on safety is required, for example power plants and oil platforms. The software is currently written in C and C++, languages that are not optimal from a safety point of view. In this master's thesis, it is investigated whether there are any plausible alternatives to using C/C++ for safety critical real-time systems. A number of requirements that programming languages used in this area have to fulfill are stated and it is evaluated if some candidate languages fulfill these requirements. The candidate languages, Java and Ada, are compared to C and C++. It is determined that the Java-to-C compiler LJRT (Lund Java-based Real Time) is a suitable alternative. The practical part of this thesis is concerned with the introduction of Java in 800xA. A module of the system is ported to Java and executed together with the original C/C++ solution. The functionality of the system is tested using a formal test suite and the performance and memory footprint of our solution is measured. The results show that it is possible to gradually introduce Java in 800xA using LJRT, which is the main contribution of this thesis

Towards an embedded real-time Java virtual machine

Most computers today are embedded, i.e. they are built into some products or system that is not perceived as a computer. It is highly desirable to use modern safe object-oriented software techniques for a rapid development of reliable systems. However, languages and run-time platforms for embedded systems have not kept up with the front line of language development. Reasons include complex and, in some cases, contradictory requirements on timing, concurrency, predictability, safety, and flexibility. A carefully tailored Java virtual machine (called IVM) is proposed as an approach to overcome these difficulties. In particular, real-time garbage collection has been considered an essential part. The set of bytecodes has been revised to require less memory and to facilitate predictable execution. To further reduce the memory footprint, the class loader can be located outside the embedded processor. Since the accomplished concurrency is crucial for the function of many embedded applications, the scheduling can be defined on the application level in Java. Finally considering future needs for flexibility and on-line configuration of embedded system, the IVM has a unique structure with which, for instance, methods being objects that can be replaced and GCed. The approach has been experimentally verified by a full prototype implementation of such a virtual machine. By making the prototype available for development of real products, this in turn has confronted the solutions with real industrial demands. It was found that the IVM can be easily integrated in typical systems today and the mentioned requirements are fulfilled. Based on experiences from more than 10 projects utilising the novel Java-oriented techniques, there are reasons to believe that the proposed approach is very promising for future flexible embedded systems

Efficient Region-Based Memory Management for Resource-limited Real-Time Embedded Systems.

This paper presents a simple and efficient static analysis algorithm, combined with a region allocation policy for real-time embedded Java applications. The goal of this work is to provide a static analysis mechanism efficient enough to be integrated in an assisted-development environment, and to implement region-based memory management primitives suited for resource-limited platforms such as smart cards

Static Data Flow Analysis for Realtime Java Runtime Error Detection

International audienceThe strict and clear semantics of Java make it an ideal language for static analysis. Nevertheless, the use of programwide pointer analysis for proving the absence of Java runtime error conditions such as null pointer uses or illegal array indices is still not widespread. Current uses of program-wide pointer analysis focus on extracting information for optimisations in compilers. In this case, imprecise analysis results only in less agressive optimisation, which is often tolerable.Existing implementations of program-wide data flow analysis either lack the required accuracy to prove the absence of large enough numbers of certain errors or cause an explosion in analysis time and space requirements for non-trivial applications. Low accuracy leads to large numbers of “false positives”, i.e., code for which the analysis fails to prove that a certain error condition does not occur. An explosion in the analysis effort causes the analysis not to produce any useful results within reasonable time at all.The approach presented in this paper applies the analysis to create a correctness proof of safety-critical Java applications. This includes the absence of runtime errors (null pointer use, division by zero, etc.), the absence of potential deadlocks, the correctness of region-based memory management and the determination of resource constraints (heap and stack use)

A switchable approach to large object allocation in real-time Java

Over the last 20 years object-oriented programming languages and managed run-times like Java have been very popular because of their software engineering benefits. Despite their popularity in many application areas, they have not been considered suitable for real-time programming. Besides many other factors, one of the barriers that prevent their acceptance in the development of real-time systems is the long pause times that may arise during large object allocation. This paper examines different kinds of solutions that have been developed so far and introduces a switchable approach to large object allocation in real-time Java. A synthetic benchmark application that is developed to evaluate the effectiveness of the presented technique against other currently implemented techniques is also described