447,492 research outputs found
A Hardware Time Manager Implementation for the Xenomai Real-Time Kernel of Embedded Linux
Nowadays, the use of embedded operating systems in different embedded
projects is subject to a tremendous growth. Embedded Linux is becoming one of
those most popular EOSs due to its modularity, efficiency, reliability, and
cost. One way to make it hard real-time is to include a real-time kernel like
Xenomai. One of the key characteristics of a Real-Time Operating System (RTOS)
is its ability to meet execution time deadlines deterministically. So, the more
precise and flexible the time management can be, the better it can handle
efficiently the determinism for different embedded applications. RTOS time
precision is characterized by a specific periodic interrupt service controlled
by a software time manager. The smaller the period of the interrupt, the better
the precision of the RTOS, the more it overloads the CPU, and though reduces
the overall efficiency of the RTOS. In this paper, we propose to drastically
reduce these overheads by migrating the time management service of Xenomai into
a configurable hardware component to relieve the CPU. The hardware component is
implemented in a Field Programmable Gate Array coupled to the CPU. This work
was achieved in a Master degree project where students could apprehend many
fields of embedded systems: RTOS programming, hardware design, performance
evaluation, etc.Comment: Embed With Linux (EWiLi) workshop, Lorient : France (2012
Asynchronous real-time ethernet
The Industrial Ethernet has become a way to build distributed systems in industrial networks which must provide predictable performance and maintainability. Industrial applications require time-critical processing, which can be guaranteed within soft or hard real-time environments, Where applications' responses require deterministic processing time, the hard real-time environment is requested. The Fieldbus protocols are the standard way to connect instruments on the Ethernet-based communication. Fieldbuses require synchronisation and dedicated application-specific integrated circuits, what leaves space for alternate, more common solutions. This thesis presents design, implementation, and evaluation of the novel Real-Time Driver Model asynchronous communication stack called 61850CS API. 61850CS stack is implemented in an intelligent electronic device to enable real-time IEC 61850 GOOSE Ethernet communications in electrical substations. The presented 61850CS implementation enables simultaneous flow of real-time and non-real-time Ethernet traffic over the same physical network interface controller. The same technology supports running arbitrary real-time Ethernet traffic and non real-time Ethernet traffic simultaneously and its implementation is general enough to enable an API use on different architectures and to comply with different industrial Ethernet requirements. And more, since 61850CS doesn't affect CSMA/CD mechanism, it doesn't need any master nodes, which increases the system availability.
The presented solution was implemented as an application programming interface for feeder protection and control (FPC 680) intelligent electronic device relay. Hardware platform for 61850CS was PPC440EPx microcontroller with implemented Linux Real-Time application interface RTOS. The FPC 680 is an IED commercial product by Iskra d.d. which is implemented worldwide in several substations
Asynchronous real-time ethernet
The Industrial Ethernet has become a way to build distributed systems in industrial networks which must provide predictable performance and maintainability. Industrial applications require time-critical processing, which can be guaranteed within soft or hard real-time environments, Where applications' responses require deterministic processing time, the hard real-time environment is requested. The Fieldbus protocols are the standard way to connect instruments on the Ethernet-based communication. Fieldbuses require synchronisation and dedicated application-specific integrated circuits, what leaves space for alternate, more common solutions. This thesis presents design, implementation, and evaluation of the novel Real-Time Driver Model asynchronous communication stack called 61850CS API. 61850CS stack is implemented in an intelligent electronic device to enable real-time IEC 61850 GOOSE Ethernet communications in electrical substations. The presented 61850CS implementation enables simultaneous flow of real-time and non-real-time Ethernet traffic over the same physical network interface controller. The same technology supports running arbitrary real-time Ethernet traffic and non real-time Ethernet traffic simultaneously and its implementation is general enough to enable an API use on different architectures and to comply with different industrial Ethernet requirements. And more, since 61850CS doesn't affect CSMA/CD mechanism, it doesn't need any master nodes, which increases the system availability.
The presented solution was implemented as an application programming interface for feeder protection and control (FPC 680) intelligent electronic device relay. Hardware platform for 61850CS was PPC440EPx microcontroller with implemented Linux Real-Time application interface RTOS. The FPC 680 is an IED commercial product by Iskra d.d. which is implemented worldwide in several substations
Scheduling periodic jobs using imprecise results
One approach to avoid timing faults in hard, real-time systems is to make available intermediate, imprecise results produced by real-time processes. When a result of the desired quality cannot be produced in time, an imprecise result of acceptable quality produced before the deadline can be used. The problem of scheduling periodic jobs to meet deadlines on a system that provides the necessary programming language primitives and run-time support for processes to return imprecise results is discussed. Since the scheduler may choose to terminate a task before it is completed, causing it to produce an acceptable but imprecise result, the amount of processor time assigned to any task in a valid schedule can be less than the amount of time required to complete the task. A meaningful formulation of the scheduling problem must take into account the overall quality of the results. Depending on the different types of undesirable effects caused by errors, jobs are classified as type N or type C. For type N jobs, the effects of errors in results produced in different periods are not cumulative. A reasonable performance measure is the average error over all jobs. Three heuristic algorithms that lead to feasible schedules with small average errors are described. For type C jobs, the undesirable effects of errors produced in different periods are cumulative. Schedulability criteria of type C jobs are discussed
A programming-language extension for distributed real-time systems
In this paper we propose a method for extending programming languages that enables the specification of timing properties of systems. The way time is treated is not language specific and the extension can therefore be included in many existing programming languages. The presented method includes a view on the system development process. An essential feature is that it enables the construction of (hard) real-time programs that may be proven correct independently of the properties of the machines that are used for their execution. It therefore provides a similar abstraction from the execution platform as is normal for non-real-time languages. The aim of this paper is to illustrate the method and demonstrate its applicability to actual real-time problems. To this end we define a simple programming language that includes the timing extension. We present a formal semantics for a characteristic part of the language constructs and apply formal methods to prove the correctness of a small example program. We consider in detail a larger example, namely the mine-pump problem known from the literature. We construct a real-time program for this problem and describe various ways to map the program to an implementation for different platforms
Intelligent Systems Development in a Non Engineering Curriculum
Much of computer system development today is programming in the large - systems of millions of lines of code distributed across servers and the web. At the same time, microcontrollers have also become pervasive in everyday products, economical to manufacture, and represent a different level of learning about system development. Real world systems at this level require integrated development of custom hardware and software.
How can academic institutions give students a view of this other extreme - programming on small microcontrollers with specialized hardware? Full scale system development including custom hardware and software is expensive, beyond the range of any but the larger engineering oriented universities, and hard to fit into a typical length course. The course described here is a solution using microcontroller programming in high level language, small hardware components, and the Arduino open source microcontroller. The results of the hands-on course show that student programmers with limited hardware knowledge are able to build custom devices, handle the complexity of basic hardware design, and learn to appreciate the differences between large and small scale programming
Student-project allocation with preferences over projects: algorithmic and experimental results
We study the Student-Project Allocation problem with lecturer preferences over Projects (spa-p). In this context it is known that stable matchings can have different sizes and the problem of finding a maximum size stable matching is NP-hard. There are two known approximation algorithms for max-spa-p, with performance guarantees 2 and . We show that max-spa-p is polynomial-time solvable if there is only one lecturer involved, and NP-hard to approximate within some constant if there are two lecturers involved. We also show that this problem remains NP-hard if each preference list is of length at most 3, with an arbitrary number of lecturers. We then describe an Integer Programming (IP) model to enable max-spa-p to be solved optimally in the general case. Following this, we present results arising from an empirical evaluation that investigates how the solutions produced by the approximation algorithms compare to optimal solutions obtained from the IP model, with respect to the size of the stable matchings constructed, on instances that are both randomly-generated and derived from real datasets
Program Komputasi Ranked Positional Weight Untuk Keseimbangan Lintasan Perakitan
Assembly line balancing (ALBP) is a problem that often occurs in industrial engineering as part of the NP-hard combinatorial optimization problem. Which means no one can guarantee the optimal solution in solving the problems. ALBP used to solve balance optimization problem with a series of elements that are assigned to work in a particular station by the restrictions that have been set. Input needed to obtain optimal results include work element, cycle time, process time for each work element and number of predecessors. These data are needed in large number for the implementation in the real world and is not recommended to do calculations manually because it required long time. This paper implements one of line balancing algorithm i.e. Ranked Positional Weight (RPW) designed using Java programming language. The program can read a maximum of 50 work elements and a maximum of 3 predecessors for each element executed with 3 different times. The results will be the optimum number of work stations, work elements assigned to each station and line balance efficiency for each different cycle time
Sum-of-squares proofs and the quest toward optimal algorithms
In order to obtain the best-known guarantees, algorithms are traditionally
tailored to the particular problem we want to solve. Two recent developments,
the Unique Games Conjecture (UGC) and the Sum-of-Squares (SOS) method,
surprisingly suggest that this tailoring is not necessary and that a single
efficient algorithm could achieve best possible guarantees for a wide range of
different problems.
The Unique Games Conjecture (UGC) is a tantalizing conjecture in
computational complexity, which, if true, will shed light on the complexity of
a great many problems. In particular this conjecture predicts that a single
concrete algorithm provides optimal guarantees among all efficient algorithms
for a large class of computational problems.
The Sum-of-Squares (SOS) method is a general approach for solving systems of
polynomial constraints. This approach is studied in several scientific
disciplines, including real algebraic geometry, proof complexity, control
theory, and mathematical programming, and has found applications in fields as
diverse as quantum information theory, formal verification, game theory and
many others.
We survey some connections that were recently uncovered between the Unique
Games Conjecture and the Sum-of-Squares method. In particular, we discuss new
tools to rigorously bound the running time of the SOS method for obtaining
approximate solutions to hard optimization problems, and how these tools give
the potential for the sum-of-squares method to provide new guarantees for many
problems of interest, and possibly to even refute the UGC.Comment: Survey. To appear in proceedings of ICM 201
- …