Search

Safety critical applications require embedded software that can guarantee deterministic output and on time results during execution. Synchronous programming languages are by nature focused on providing the programmer with deterministic output at fixed points in time [1, 2]. Synchronous programming languages such as Esterel [3], LUSTRE [4], SIGNAL [5], etc., have successfully generated sequential software for embedded applications targeting avionics, rail transport, etc. The underlying formalism of these languages is robust and the associated software tools provide correctness preserving refinement from the specification to implementation. But even within the class of synchronous programming languages, there are very distinctive Models of Computation (MoC) [6]. Esterel and LUSTRE use an external global tick (or global clock) as reference for events that occur in the system. SIGNAL has an entirely different Model of Computation, where no assumptions are made on the global tick while designing the system. Each event has its own tick associated with it and for compilation the analysis of the specification would have to yield a totally ordered tick from the specification. In its absence, a variable (also known as signal) is constructed which has an event happening in synchrony with every event occurring in the system. This signal can be viewed as a root clock of the system with a hierarchical tree structure relating it with every other signal. Since events can occur at each signal at different rates, this MoC is also known as polychronous or multi-rate.

Embedded programming is a device software which plays an integral part in the electronics device. Embedded software’s principal role is not information technology, but rather the interaction with the physical world. It is written for machines that are not, first and foremost, computers. Embedded software is “built in” to the electronics in cars, telephones, audio equipment, robots, appliances, toys, security systems, pacemakers, televisions, digital watches, airplanes, missiles, process control, RFID devices, and monitoring systems, for example. Embedded software is usually written for special-purpose hardware. Application-specific embedded software has been developed for programming RFID devices to function as coordinator, router, end device, and various other purposes (Bandyoadhyay et al., 2007).

The wireless information and safety system for mines of the present invention enables continuously tracking and monitoring underground miners and moveable equipment in underground mines using ZigBee-enabled active RFID devices forming a wireless network among them and other static and mobile ZigBee devices placed at strategic locations. The present invention provides a wireless information and safety system for mines comprises in combination of ZigBee-compliant devices (programmable to operate as end devices, routers and coordinators by hardware specific embedded software) and wireless sensor network (WSN) software having various application modules both for underground and opencast mines. Use of the system of the present invention would help in identifying the miners entering in underground mine to keep the track of the miners and maintain computerized attendance. This would help in monitoring equipment locations and their operation to improve productivity and reduce fatal collision accident. This would help in locating and tracking the miners in case of disaster for speedy rescue operation. This would help in monitoring miners' unsafe practice and providing warning to the respective miner. This would further help in real time monitoring environmental parameters in underground mine. This would also help in sending coded message to the concerned person in underground mine. This would further help in monitoring movement of dumpers in opencast mine, which will ultimately help in optimum shovel-dumper performance and improving productivity.

We can easily find embedded systems everywhere in our daily lives. The numbers of embedded systems are rapidly growing especially in wireless and web applications. The embedded systems market is one of the fastest growing areas in the world. By name, an embedded system is a special-purpose computing device designed to perform dedicated functions. Some of the embedded systems with real-time constraints are called real-time embedded systems. An embedded system consists of its hardware and software. The hardware includes a microprocessor or microcontroller with additional attached external memory, I/O, and other components such as sensors, keypad, LEDs, LCDs, and any kind of actuators. The embedded software is the driving force of an embedded system. Most real-time embedded systems software has specific application programs supported by a Real Time Operating System (RTOS). The embedded software is usually called firmware because this type software is loaded to ROM, EPROM, or Flash memory, and once it is loaded it will never be changed unless it needs to be reloaded or replaced. This book introduces the fundamentals of embedded system design and development. The focus is emphasized on the software aspect of embedded systems design and development. You will enjoy the hands-on experience of building embedded systems on your own with this book.

Embedded system design: modeling, synthesis and verification introduces a model-based approach to system level design. It presents modeling techniques for both computation and communication at different levels of abstraction, such as specification, transaction level and cycle-accurate level. It discusses synthesis methods for system level architectures, embedded software and hardware components. Using these methods, designers can develop applications with high level models, which are automatically translatable to low level implementations. This book, furthermore, describes simulation-based and formal verification methods that are essential for achieving design confidence. The book concludes with an overview of existing tools along with a design case study outlining the practice of embedded system design. Specifically, this book addresses the following topics in detail: . System modeling at different abstraction levels . Model-based system design . Hardware/Software codesign . Software and Hardware component synthesis . System verification This book is for groups within the embedded system community: students in courses on embedded systems, embedded application developers, system designers and managers, CAD tool developers, design automation, and system engineering.

The embedded system software development has the same Software Development Life Cycle (SDLC) just like any other software development, plus special consideration for resource constraints, including CPU, time, memory, operating system, multi-tasking concurrency, and many other non-functional attribute constraints. In order to reduce the time-to-market and guarantee the reliability of the embedded system product, software engineering methodology is recommended for the software design and development. Because the embedded software is not deployed on a general purpose computer system, the embedded software in C/C++ or other high level programming languages must be developed and tested on a cross-platform machine such as a PC, and then loaded to a target microcontroller memory to be tested as shown in Figure 2.1.

This chapter introduces 8051 C programming. The 8051 C is designed for programming the 8051 microcontroller. It is both an extension and subset of ANSI C. It is assumed that the readers of this book have basic C programming knowledge. The ANSI C syntax is given in Appendix A for your reference. The difference in programming with 8051 C compared to ANSI C programming are all about the microcontroller architecture such as I/O ports, memory, CPU registers, timers and interrupts. Everybody knows C is the closest to assembly language and is a better choice for large and complex system software, device drivers, or embedded software. However, it is still platform independent so that ANSI C may not be the best choice for the time critical or resource critical software project. It is difficult to write projects in machine dependent assembly language because the programmer must know all the hardware details, and it is difficult to do debugging, testing, and maintenance. The 8051 C is between the C standard language and “51” family assembly language. It will be much easier for a C programmer to switch to 8051 C because he/she only needs to learn the extensions to the language and to deal with missing parts of the standard library. Assembly instructions can be embedded into 8051 C programs if it is necessary. Most microcontrollers have a dedicated C compiler available just like the 8051 C for “8051” family microcontrollers. This chapter will discuss the C extension related hardware so that you will have a better understanding of the foundation of the 8051 microcontroller before you do coding in 8051 C.

Sorting is an important operation for a number of embedded applications. As sorting large datasets may impose undesired performance degradation, acceleration units coupled to the embedded processor can be an interesting solution for speeding-up the computations. This paper presents and evaluates three hardware sorting units, bearing in mind embedded computing systems implemented with FPGAs. The proposed architectures take advantage of specific FPGA hardware resources to increase efficiency. Experimental results show the differences in resources and performances among the three proposed sorting units and also between the sorting units and pure software implementations for sorting.We show that a hybrid between an insertion sorting unit and a merge FIFO sorting unit provides a speed-up between 1.6 and 25 compared to a quicksort software implementation.

Summary form only given. Many tasks in safety-critical embedded systems have hard real-time characteristics. Failure to meet deadlines may result in the loss of life or in large damages. Utmost carefulness and state-of-the-art machinery have to be applied to make sure that all requirements are met. To do so lies in the responsibility of the designer(s). Fortunately, the state of the art in deriving run-time guarantees for real-time systems has progressed so much that tools based on sound methods are commercially available and have proved their usability in industrial practice.

The automotive industry has recent ambitions to integrate multiple applications from different micro controllers on a single, more powerful micro controller. The outcome of this integration process is the loss of the physical isolation and a more complex monolithic software. Memory protection mechanisms need to be provided that allow for a safe co-existence of heterogeneous software from different vendors on the same hardware, in order to prevent the spreading of an error to the other applications on the controller and leaving an unclear responsibility situation. With our prototype system KESO, we present a Java-based solution for robust and safe embedded real-time systems that does not require any hardware protection mechanisms. Based on an OSEK/VDX operating system, we offer a familiar system creation process to developers of embedded software and also provide the key benefits of Java to the embedded world. To the best of our knowledge, we present the first Multi-JVM for OSEK/VDX operating systems. We report on our experiences in integrating Java and an embedded operating system with focus on the footprint and the real-time capabilities of the system.

System level design is considered a major approach to tackle the complexity of modern System-on-Chip designs. Embedded software within SoCs is gaining importance as it addresses the increasing need for flexible and feature-rich solutions. Therefore, integrating software design and co-simulation into a system level design flow is highly desirable. In this article, we present the software perspective within our systemlevel design flow. We address three major aspects: (1) modeling of a processor (from abstract to ISS-based), (2) porting of an RTOS, and (3) the embedded software generation including RTOS targeting. We describe these aspects based on a case study for the ARM7TDMI processor. We show processor models including a cycle-accurate ISSbased model (using SWARM), which executes the RTOS MicroC/OS-II. We demonstrate our flow with an automotive application of anti-lock breaks using one ECU and CAN-connected sensors. Our experimental results show that automatic SW generation is achievable and that SW designers can utilize the system level benefits. This allows the designer to develop applications more efficiently at the abstract system level.

Over recent years, embedded systems have gained an enormous amount of processing power and functionality. Many of the formerly external components can now be integrated into a single System-on-Chip. This tendency has resulted in a dramatic reduction in the size and cost of embedded systems. As a unique technology, the design of embedded systems is an essential element of many innovations. Embedded System Design: Topics, Techniques and Trends presents the technical program of the International Embedded Systems Symposium (IESS) 2007 held in Irvine, California. IESS is a unique forum to present novel ideas, exchange timely research results, and discuss the state of the art and future trends in the field of embedded systems. Contributors and participants from both industry and academia take active part in this symposium. The IESS conference is organized by the Computer Systems Technology committee (TC10) of the International Federation for Information Processing (IFIP). Timley topics, techniques and trends in embedded system design are covered by the chapters in this book, including design methodology, specification and modeling, embedded software and hardware synthesis, networks-on-chip, distributed and networked systems, and system verification and validation. Particular emphaisis is paid to automotive and medical applications. A set of actual case studies and special aspects in embedded system design are included as well.

In the 1940s the electronic history was marked by the invention of the transistor and only a decade after the first Integrated Circuit (IC) was realized. Nowadays, few decades after that invention, the CMOS Technology Platform is putting us in front of another major forefront: the capability to realize an entire system on a single piece of silicon, the so called System On a Chip (SoC), integrating many million transistors into a single integrated device. This incredible technology evolution is very well described and predicted by the “Moore’s Law”. The silicon technology has improved over the past years giving us nowadays the capability of building Ics in CMOS technologies with minimum linear features of 0.09 µm (90 nm). Thanks to that we will are able to build silicon chips in excess of tens, or even hundreds, million transistors. Various functionalities, like memories, logic, analog, CPU, DSP, MPEG decoder/encoders, etc. can be integrated into a single silicon chip realizing an entire System On a single Chip (SoC). At that level of integration hardware will no more be the only IC “king”: software, or better “embedded software”, will become part of the SoC definition and functionality. On top of that, we will face both a continuous decrease of the time to market window and a very rapid chievement of mass production volumes. Clearly those levels of integration can’t be achieved only thanks to technology improvements. A full Technology Platform is needed, composed by: process capabilities, design methodologies, design automation, software tools, basic library components, complex macroblocks (often called IP, Intellectual Properties). In this Chapter we will cover all the issues that are here mentioned and that are key for the success of an SOC realization using the most advanced CMOS Technology Platform.

ISBN: 1-4020-7528-6; Embedded Software for SoC covers all software related aspects of SoC design: -Embedded and application-domain specific operating systems, interplay between application, operating system, and architecture. -System architecture for future SoC, application-specific architectures based on embedded processors and requiring sophisticated hardware/software interfaces. -Compilers and interplay between compilers and architectures. -Embedded software for applications in the domains of automotive, avionics, multimedia, telecom, networking.

In this paper we present our methodology for modeling a priority-based preemptive real time operating system (RTOS) kernel in SystemC. We use the current modeling constructs of SystemC 2.0 and throughout our development of the kernel’s system calls we propose new constructs that can be used in RTOS modeling. We show then the interaction of the embedded software module consisting of the RTOS kernel and the running application tasks with a hardware module representing a bus functional model (BFM) of a generic microcontroller.

The paper describes techniques, which have been developed to simplify the customization of the PURE operating system family for embedded systems and can be applied to almost any embedded software intended for reuse. The approach is based on feature modeling and the use of aspect-oriented programming and supported by a complete tool chain.

The main purpose of this paper is to discuss if the Unified Modeling Language (UML) can be used as a system-level language (SLL) for specifying embedded systems, in co-design environments. The requirements that a language has to fulfil to be considered as an SLL are presented and the advantages and disadvantages of using UML as an SLL are also indicated. The contribution of this paper consists on the explicit discussion of the key issues that must be taken into account when deciding if UML is to be used in a project as an SLL for embedded software.

IP-based hardware design became an important topic during the past years. There is an even older tradition of reuse of software components. In this contribution we try to address some key problems of software reuse. First of all, in a bottom-up approach we study some underlying communication techniques used to couple different software components. As the most general solution of this problem is CORBA (Common Object Request Broker Architecture) from our point of view, this technique is discussed briefly. From the bottom we move directly to the top. The most flexible way of handling reusable software IP is to deal with their abstract model. Following this approach, modules can be embedded to various target environments using standard synthesis methods. The problem of protecting property in this approach is not discussed in this chapter. We concentrate on how to combine modules that have been modelled in various languages. At least when using a language coupling approach strict support to define bridging semantics has to be provided. A very useful means for this purpose is given by the ASM (Abstract State Machine) method, which is shortly introduced in the chapter. When software IP has to be used this IP resides on various databases in most cases. We discuss, how design workflows can be defined that allow to access such remote IPs. The exchange format XML plays an important role in this context. Finally we discuss an application example: the application-specific synthesis of real-time operating systems (RTOS) and real-time communication systems (RCOS) from a library of reusable and highly generic software modules.

The design of concurrent real-time embedded systems, and embedded software in particular, is a difficult task, which is hard to perform manually due to the complex consumer-producer relations, the presence of various timing constraints and the tight interaction with the underlying hardware. We present here a new approach which supports the automated implementation of concurrent behavior on a single processor (multi-tasking) (and with some additional extensions also on multiple processors). More specifically, it tackles the problem of task scheduling under real-time constraints. The processor can be either an application-specific processor or an instruction-set (i.e. programmable) processor. The approach uses as much as possible pre-ordering of the concurrent behavior under real-time constraints to minimize the run-time overhead. Consequently, a minimal application-specific multi-tasking kernel is synthesized for the software portion1 to facilitate the coordination of the partially ordered tasks, featuring selectable process scheduling models dedicated to the needs of the application. This approach has the advantage that real-time constraints can be guaranteed and the synthesized kernel (for the software portion) will likely be significantly more simple than a generic (RT)OS solution. Section 1 below gives an overview of the system synthesis methodology and introduces the concepts used in the remainder of the text.