DEGAS

A new approach based on genetic algorithm (GA) and autonomous mental development for trajectory planning of robot manipulator is presented in this paper. The trajectory for the manipulator is optimized by the GA. To make the trajectory planning used in real time application, a developmental learning algorithm is proposed to generate an incremental hierarchical discriminating regression (IHDR) tree to form the mapping from the state space to the action space. Just like the human brain from infancy to adulthood, the algorithm develops its cognitive and behavioral skills through online learning from the samples obtained from the GA-based method. When the IHDR tree is generated, it can perform the trajectory planning in real time by retrieving in its knowledge database.

: This research is directed towards the implementation of a comprehensive toolkit for the development and verification of high assurance reactive systems, especially concurrent, real time, and hybrid systems. For this, we have designed and implemented the STeP (Stanford Temporal Prover) verification system. STeP is a tool for the computer aided formal verification of reactive systems, including real time and hybrid systems based on their temporal specification. STeP integrates model checking and deductive methods to allow the verification of a broad class of systems, including parameterized (N component) circuit designs, parameterized (N process) programs. and programs with infinite data domains.

Real-time systems are those systems in which the correctness of the system depends not only on the logical results of computation but also on the time at which the results are produced [Stankovic 1988]. They span a broad spectrum of complexity from very simple microcontrollers in embedded systems (a microprocessor controlling an automobile engine) to highly sophisticated, complex, and distributed systems (air traffic control for the continental United States). Other real-time systems include command and control systems, process control systems, and multimedia and high-speed communication systems. Some real-time systems are beginning to add expert systems and other AI technology, creating additional requirements and complexities. At least three major trends in the real-time and embedded systems field have had a major impact on its technology: the increased growth and sophistication of embedded systems, the development of more scientific and technological results for hard real-time systems, and the advent of distributed multimedia. Most embedded systems consist of a small microcontroller and limited software situated within some product such as a microwave oven or automobile. However, with the increasing sophistication of such systems, powerful microcontrollers and digital signal processing (DSP) chips are commonly used, as are off-the-shelf real-time operating systems and design and debugging tools. Many people working with embedded systems deal on a daily basis with sensors and data acquisition technology and systems; others construct architectures based on single-board computers (many are still 68000-based, but RISC processors are being used more and more) and buses such as the VME bus. Many people are involved with the programming and debugging of embedded systems, largely using the C programming language and cross development and debugging platforms. Embedded systems may or may not have real-time constraints. Hard real-time systems are those in which missing an important deadline can cause severe consequences, even death. In this area, many fundamental results have been developed. For example, in real-time scheduling, rate monotonic analysis has enabled careful evaluation of many practical systems; the concept and analysis of competitive algorithms has provided important scheduling bounds and limits; and on-line planning has added flexible and dynamic capabilities to real-time systems. Operating systems research has produced predictable primitives, time-constrained synchronization techniques, and reservation and admission-control paradigms. Many other results exist in real-time architecture, fault tolerance, communication protocols, specification and design tools, formal verification, databases and object-oriented systems. Emphasis on all these areas is expected to increase in the foreseeable future. Many hard real-time systems are embedded systems. Distributed multimedia have produced a new set of soft real-time requirements. Real-time principles lie at the heart of distributed multimedia, but without the concomitant high reliability

Unified Modeling Language is being used for modeling of business processes, real-time systems, embedded systems and hybrid systems. In software engineering, there are different techniques for verification of such systems. Model checking is one of the techniques for the automatic verification of software models. Earlier, these model were verified by sequential model checking tools. For very large complex systems, parallel verification can save verification time. DiVinE is a model checking tool for both CPUs and GPUs clusters to perform parallel linear time logic (LTL) verification of systems. In this paper, we propose a parallel verification methodology for UML models using DiVinE tool. We explain this methodology by the case study example of fuel filling machine.

2025 29th International Symposium on Distributed Simulation and Real Time Applications (DS-RT)

Middleware implementation of various critical services required by large scale and complex real time applications on top of COTS operating system is currently an approach of growing interests. Its main goal is to enable significant reduction application system design separating the concerns of the application designer for the application functionality from the concerns for application independent system issues. The paper presents the middleware architecture named the Real-time Object-oriented Adaptive Fault Tolerance Support (ROAFTS) and a prototype implementation ROAFTS/Solaris realized on top of both a COTS operating systems, Solaris, and a COTS CORBA complaint ORB, Orbix. ROAFTS supports distributed real time applications, each structured as a network of Time-triggered Message-triggered Objects (TMOs), and the TMO is a major extension of a conventional object for use in hard real time applications. The major components of ROAFTS include a TMO support manager for supporting the execution of TMO's, a generic fault tolerance server, and a network surveillance manager (NSM) which provides the generic fault tolerance server with fast fault detection notices. The generic fault tolerance server and the NSM themselves have been structured as TMO's. A discussion on an effective use of CORBA standards for moderate precision real time applications to run on COTS operating systems is also presented.

The GNSS time transfer technology is the high precision time transfer method based on the navigation satellite system and has been widely applied in time and frequency. Benefiting from the development of GNSS time transfer technology and the expansion of user needs for real-time time service applications, real-time time transfer technology has become an important research direction. GNSS Precise Point Positioning (PPP) is one of the most commonly used methods of GNSS time transfer technology. With the development of the many facilities, the application of the real-time GNSS PPP has become wider and wider. In this paper, we demonstrate and evaluate the performance of the international GNSS service (IGS) products in the near real-time PPP time transfer technology. A set of the PPP solutions were computed from the observed data from the timekeeping laboratories, and three types of products provided by IGS, including Ultra-Rapid (IGU), Rapid (IGR), and Final (IGS final) orbit and clock offset products. IGS final and IGR products have extremely high accuracy and stability and are used as a reference for the time transfer with IGU product. The near real time clock offset and the comparison link performed with the IGU product can provide a time comparison service with an accuracy of 0. 5ns for near real time applications.

Formal Verification of Compiler Transformations for Speculative Real-Time Execution>>>A short version of t>his paper was presented at the 20th IFAC/IFIP Workshop on Real Time Programming (WRTP’95), which was held in Gt. Lauderdale, Florida, U.S.A., during November 1995. The Published Proceedings of this IFAC Meeting may be ordered from: Elsevier Science Limited, The Boulevard, Langford Lane, Kidlington, Oxford OX5 1GB, United

This paper discuss on how to develop a hard real-time machine control system with Microsoft Windows NT Operating System, where the respond must be within 0.5 milliseconds. The attempt to use a general-purpose operating system (Microsoft Windows NT 4.0 Workstation) is because there is abundance of Commercial-Off-the-Shelf Components (COTS), easily available tools (compilers, and 3 party tools) and need not to learn another operating system behavior. The most important factor is there is no single dominant operating system or tools vendor for real-time operating system. Since the no single dominant real-time operating system development under real-time operating system is riskier and more costly. Ideally codes must be portable between different operating system where it is apparent with Windows platforms, Windows 95/98, Windows ME, Windows 2000, Windows XP or even Windows CE. Firstly study was done on how Microsoft Windows NT operating system works internally from materials from Microsoft Software Development Network (MSDN). Secondly study was done how to take advantage of the operating system to create a real time application. Microsoft Windows NT is a general purpose operating system that does not support real time application development, but it has all the vital elements that a real time operating system needs. The vital elements are priority-driven, preemptive scheduler, preemptive interrupt handler (for critical interrupts), deferred procedure calls (DPC) for non-critical (DPC executes after ISR), synchronization and deterministic response time. With these vital elements and some modification to application codes to enable it to execute in higher priority level, would result a real time application. This does not mean changing all the codes to higher priority is the solution, as it would cause system to malfunction as other device driver or low-level interface run at high priority too and this would lock up the system. With the combination of priority level, synchronization a complete real time solution can be implemented and this paper covers the concept. This concept also explains what was done to overcome the need of special hardware (as recommended) to accomplish hard real-time application with the response of 0.5 milliseconds.

Leveraging virtualization technology, Mobile Edge Computing (MEC) deploys multiple services with different execution time requirements running as isolated processes. For instance, both real-time (RT) and non-RT applications may be (are) running on the same infrastructure using containerized virtualization. Nevertheless, sharing resources (e.g., CPU) with collocated workloads could impact the RT performance of RT applications. This paper presents PRINCIPIA, a dynamic CPU and CPU-shares allocation mechanism that opportunistically enables non-RT applications to run on underutilized CPUs while providing RT guarantees to RT applications. By monitoring MEC’s system metrics like processor’s CPU utilization and container’s CPU usage, PRINCIPIA dynamically allocates both CPU and CPU-shares to containers running non-RT applications aiming at opportunistically exploiting underutilized CPUs by containers running RT applications. We evaluate PRINCIPIA on a small-scale MEC server which uses containerized virtualization along with Linux RT Kernel to deploy both RT and non-RT applications. Our findings show that PRINCIPIA mitigates the impact on the RT performance of RT applications providing bounded processing latency in comparison with the default host Kernel scheduler.

For decades, the problem of solving the dynamics of mechanisms has been investigated by many researchers. This is because knowing the dynamics of mechanisms is required in order to implement control and analysis systems on these mechanisms. Recently, Nick Hillier has developed detailed algorithms that have the potential to solve for the dynamics of linkages for real time applications; although, to date these algorithms have not been implemented in a way so that they can be used in real time applications.Hillier (2006) wrote several algorithms deal with machines made of serial linkages and closed loop linkages. The purpose of this thesis is to implement the algorithms written for serial linkages in C++ and to evaluate whether this implementation is suitable for use in real time applications. Another aspect of this thesis is to develop the code using an object-orientated approach so that the code is easy to use and so that all of its components are reusable.Hillier’s algorithms for serial linkages have two purposes: to calculate the forward dynamics of a system and to linearise the dynamics into a state-space form so that it can be used by control applications such as a Kalman filter. Both aspects of these algorithms have been successfully implemented and thoroughly tested using systems made of one, two and six bodies.The program has been developed using a range of objects that effectively abstract the workings of the algorithm from the user and have all been proven to be self-sufficient.Therefore, the program is easy to use and all aspects of the code can be transplanted into larger programs.A downside of the implementation is that it has been proven not to be suitable for real-time applications. The speed of the algorithm has been testing on a standard computer and has shown to require approximately 0.17 seconds per time-step when integrating the forward dynamics of a system comprised of six linkages. Programs need to work in the order of 0.04 seconds per time-step to be suitable for real-time applications. Note however, it requires slightly less time for system with fewer linkages and if a system has only one or two linkages it can be used in real time applications.

This paper presents an overview of a proposed protocol to provide application---transparent fault tolerant services in a Real Time Operating system. Fault tolerance is achieved by saving checkpoints of the processes belonging to a real time application. This approach proposes the extension of some real time system calls in order to save a recovery point when the user invokes them. This protocol allows a real time application designer to know the temporal specifications of every system call. Current real time applications are composed of several Real Time processes and they have to share data by using interprocess communication facilities provided by the operating system. The operating system has to take into account these interactions to ensure the consistency of checkpoints. This is done by tracking the communications performed since the last checkpoint and forcing dependent processes to perform a checkpoint at the same time.

Nowadays, Wireless Mesh Networks (WMN) are increasingly supporting jointly non real-time and real time applications that required a guaranteed bandwidth. A new methodology is presented throughout this study to show that an important aspect of dimensioning WMNs, considering mobility of users, fairness and their demand according to two types of running applications. This leads to satisfying voice demand while ensuring fairness among the non delay-sensitive applications. We propose the combination of both capacity estimation based on users mobility and multipath scheme. We compare our proposition with single path routing based on the shortest path criteria in terms of end-to-end throughput to show that it performs best.

Real-time systems are used in many critical applications. Verification of these real-time systems is essential. Presented here is a method for modeling real-time systems and computing the model's timing characteristics automatically. From a data-driven model of the system an equivalent finite state machine representation of the system is produced by this package. To provide efficient traversal of this large state space an ordered binary decision diagram (OBDD) is used to represent the state machine using symbolic methods. Algorithms have been developed to find the largest and smallest distance (times) between any two state sets. From these algorithms schedulability of the real-time system can be determined.

Today, the number of versatile real-time mobile applications is vast, each requiring different data rate, Quality of Service (QoS) and connection availability requirements. There have been strong demands for pervasive communication with advances in wireless technologies. Real-time applications experience significant performance bottlenecks in heterogeneous networks. A critical time for a real-time application is when a vertical handover is done between different radio access technologies. It requires a lot of signalling causing unwanted interruptions to real-time applications. This work presents a utilization of learning algorithms to give time for applications to prepare itself for vertical handovers in the heterogeneous network environment. A testbed has been implemented, which collects PHY (Physical layer), application level QoS and users context information from a terminal and combines these Key Performance Indicators (KPI) with network planning information in order to anticipate vertical handovers by taking into account the preparation time required by a specific real-time application.