This article presents a survey of several major embedded systems. It analyzes several design issues of embedded system, such as architecture, memory management, IPC, process management, network support, and the impact of hardware limitation and application requirement of embedded system. An embedded system performs one or a few pre-defined tasks, usually with very specific requirements. The article than further emphasize common feature, characteristics, user interfaces, CPU platform, Debugging, Reliability, Tools, Peripherals, Types of Embedded system, Embedded Software Architecture.
An embedded system is a special-purpose system in which the computer is completely encapsulated by or dedicated to the device or system it controls. Unlike a general-purpose computer, such as a personal computer, an embedded system performs one or a few pre-defined tasks, usually with very specific requirements. Since the system is dedicated to specific tasks, design engineers can optimize it, reducing the size and cost of the product. Embedded systems are often mass-produced, benefiting from economies of scale.
In the earliest years of computers in the 1940s, computers were sometimes dedicated to a single task, but were too large to be considered "embedded". Over time however, the concept of programmable controllers developed from a mix of computer technology, solid state devices, and traditional electromechanical sequences.
The modern Embedded Systems are:
- The first recognizably modern embedded system was the Apollo Guidance Computer, developed by Charles Stark Draper at the MIT Instrumentation Laboratory. At the project's inception, the Apollo guidance computer was considered the riskiest item in the Apollo project. The use of the then new monolithic integrated circuits, to reduce the size and weight, increased this risk.
- The first mass-produced embedded system was the Autonetics D-17 guidance computer for the Minuteman missile, released in 1961. It was built from transistor logic and had a hard disk for main memory. When the Minuteman II went into production in 1966, the D-17 was replaced with a new computer that was the first high-volume use of integrated circuits. This program alone reduced prices on quad nand gate ICs from $1000/each to $3/each, permitting their use in commercial products.
- Implemented with limited resources
- Real constraints and requirements
- Real time
- Fault tolerance
- Operating environment
- Combine hardware and software very
- Tightly (almost inseparably)
- Are often invisible
- Embedded systems are designed to do some specific task, rather than be a general-purpose computer for multiple tasks. Some also have real-time performance constraints that must be met, for reason such as safety and usability; others may have low or no performance requirements, allowing the system hardware to be simplified to reduce costs.
- An embedded system is not always a separate block - very often it is physically built-in to the device it is controlling
- The software written for embedded systems is often called firmware, and is stored in read-only memory or Flash memory chips rather than a disk drive. It often runs with limited computer hardware resources: small or no keyboard, screen, and little memory.
Embedded systems range from no user interface at all - dedicated only to one task - to full user interfaces similar to desktop operating systems in devices such as PDAs.
Personal Digital Assistants: Personal digital assistants (PDAs) are handheld computers that were originally designed as personal organizers, but became much more versatile over the years. PDAs are also known as pocket computers or palmtop computers. PDAs have many uses: calculation, use as a clock and calendar, playing computer games, accessing the Internet, sending and receiving E-mails, video recording, typewriting and word processing, use as an address book, making and writing on spreadsheets, use as a radio or stereo, and Global Positioning System (GPS). Newer PDAs also have both color screens and audio capabilities, enabling them to be used as mobile phones (smart phones), web browsers, or portable media players. Many PDAs can access the Internet, intranets or extranets via Wi-Fi, or Wireless Wide-Area Networks (WWANs). One of the most significant PDA characteristic is the presence of a touch screen.
Handheld Device: A Handheld device (also known as handheld computer or simply handheld) is a pocket-sized computing device, typically utilizing a small visual display screen for user output and a miniaturized keyboard for user input. In the case of the personal digital assistant (PDA) the input and output are combined into a touch-screen interface. Along with mobile computing devices such as laptops and smart phones, PDAs are becoming increasingly popular amongst those who require the assistance and convenience of a conventional computer, in environments where carrying one would not be practicable.
Types of Embedded System
There are mainly two types of Embedded System:
- Simple System
- Complex System
Simple Systems: Simple embedded devices use buttons, LEDs, and small character- or digit-only displays, often with a simple menu system.
Complex Systems: A full graphical screen, with touch sensing or screen-edge buttons provides flexibility while minimizing space used: the meaning of the buttons can change with the screen, and selection involves the natural behavior of pointing at what's desired. Handheld systems often have a screen with a "joystick button" for a pointing device. The rise of the World Wide Web has given embedded designers another quite different option: providing a web page interface over a network connection. This avoids the cost of a sophisticated display, yet provides complex input and display capabilities when needed, on another computer. This is successful for remote, permanently installed equipment. In particular, routers take advantage of this ability.
Embedded processors can be broken into two distinct categories: microprocessors (μP) and microcontrollers (μC). Microcontrollers have built-in peripherals on the chip, reducing size of the system. There are many different CPU architectures used in embedded designs such as ARM, MIPS, Coldfire/68k, PowerPC, x86, PIC, 8051, Atmel AVR, etc. This in contrast to the desktop computer market, which is currently limited to just a few competing architectures. PC/104 and PC/104+ are a typical base for small, low-volume embedded and ruggedized system design. These often use DOS, Linux, NetBSD, or an embedded real-time operating system such as QNX or VxWorks.
Embedded Systems talk with the outside world via peripherals, such as:
- Serial Communication Interfaces (SCI): RS-232, RS-422, RS-485 etc
- Synchronous Serial Communication Interface: I2C, JTAG, SPI, SSC and ESSI
- Universal Serial Bus (USB)
- Networks: Controller Area Network, Lon Works, etc
- Timers: PLL(s), Capture/Compare and Time Processing Units
- Discrete IO: aka General Purpose Input/output (GPIO)
As for other software, embedded system designers use compilers, assemblers, and debuggers to develop embedded system software. However, they may also use some more specific tools:
- An in-circuit emulator (ICE) is a hardware device that replaces or plugs into the microprocessor, and provides facilities to quickly load and debug experimental code in the system.
- Utilities to add a checksum or CRC to a program, so the embedded system can check if the program is valid.
- For systems using digital signal processing, developers may use a math workbench such as MathCAD or Mathematical to simulate the mathematics.
- Custom compilers and linkers may be used to improve optimization for the particular hardware.
- An embedded system may have its own special language or design tool or add enhancements to an existing language. Software tools can come from several sources:
- Software companies that specialize in the embedded market.
- Ported from the GNU software development tools.
- Sometimes, development tools for a personal computer can be used if the embedded processor is a close relative to a common PC processor.
Embedded Debugging may be performed at different levels, depending on the facilities available, ranging from assembly- or source-level debugging with an in-circuit emulator or in-circuit debugger, to output from serial debug ports or JTAG/Nexus interfaces, to an emulated environment running on a personal computer.
As the complexity of embedded systems grows, higher level tools and operating systems are migrating into machinery where it makes sense. For example, cell phones, personal digital assistants and other consumer computers often need significant software that is purchased or provided by a person other than the manufacturer of the electronics. In these systems, an open programming environment such as Linux, NetBSD, OSGi or Embedded Java is required so that the third-party software provider can sell to a large market.
Embedded systems often reside in machines that are expected to run continuously for years without errors and in some cases recover by them if an error occurs. Therefore the software is usually developed and tested more carefully than that for personal computers, and unreliable mechanical moving parts such as disk drives, switches or buttons are avoided.
Recovery from errors may be achieved with techniques such as a watchdog timer that resets the computer unless the software periodically notifies the watchdog. Specific reliability issues may include:
- The system cannot safely be shut down for repair, or it is too inaccessible to repair. Solutions may involve subsystems with redundant spares that can be switched over to, or software "limp modes" that provide partial function. Examples include space systems, undersea cables, navigational beacons, bore-hole systems, and automobiles.
- The system must be kept running for safety reasons. "Limp modes" are less tolerable. Often backups are selected by an operator. Examples include aircraft navigation, reactor control systems, safety-critical
- Chemical factory controls, train signals, engines on single-engine aircraft.
- The system will lose large amounts of money when shut down: Telephone switches, factory controls, bridge and elevator controls, funds transfer and market making, automated sales and service.
Embedded Software Architecture
There are several different types of software architecture in common use.
Simple control loop: In this design, the software simply has a loop. The loop calls subroutines, each of which manages a part of the hardware or software.
Iterrupt controlled system: Some embedded systems are predominantly interrupting controlled. This means that tasks performed by the system are triggered by different kinds of events. An interrupt could be generated for example by a timer in a predefined frequency, or by a serial port controller receiving a byte. These kinds of systems are used if event handlers need low latency and the event handlers are short and simple.
Usually these kinds of systems run a simple task in a main loop also, but this task is not very sensitive to unexpected delays. The tasks performed in the interrupt handlers should be kept short to keep the interrupt latency to a minimum.
Cooperative multitasking: A no pre-emptive multitasking system is very similar to the simple control loop scheme, except that the loop is hidden in an API. The programmer defines a series of tasks, and each task gets its own environment to "run" in. Then, when a task is idle, it calls an idle routine (usually called "pause", "wait", "yield", etc.).
The advantages and disadvantages are very similar to the control loop, except that adding new software is easier, by simply writing a new task, or adding to the queue-interpreter.
Pre-emptive multitasking: In this type of system, a low-level piece of code switches between tasks based on a timer. This is the level at which the system is generally considered to have an "operating system", and introduces all the complexities of managing multiple tasks running seemingly at the same time.
Any piece of task code can damage the data of another task; they must be precisely separated. Access to shared data must be controlled by some synchronization strategy, such as message queues, semaphores or a non-blocking synchronization scheme. Because of these complexities, it is common for organizations to buy a real-time operating system, allowing the application programmers to concentrate on device functionality rather than operating system services.
As we have seen, design of embedded system is greatly impacted by both the application requirement and hardware limitation.
Application requirement impact:
- The embedded system scheduling, process management, protection system design need to take into account the embedded application attributes (e.g. real-time, relatively few processes coexisting, or even single task, fixed application)
- The scalability and flexibility of embedded application is also an important issue that system designer must consider in choosing the system architecture.
Hardware Impact: Hardware platform features (e.g. lack of hard disks, small memory, no MMU support, and low power consumption) force the designer to pay special attention to the efficient usage of system resource. Upon the considerations listed above, current embedded system adopted the following design strategies: Currently embedded systems are targeted for CPU architectures ranging from x86 (CISC) to ARM, with very limited resources. They are usually designed in modular fashion or take micro-kernel structure to be flexible and optimally use hardware. Process management becomes relatively easy because the number of processes is relatively small, but scheduler is often required to satisfy real-time behavior, usually by setting high priority. IPC uses various mechanisms, the message passing passes only pointers to minimize memory usage and reduce copying. Memory management uses simplified paged virtual memory or even flat memory because MMU is simple, or even non-existent, and swapping is supported. Since mobile computing has become a trend, and most hardware have built-in network interface, network is supported in all of these systems. There seems an ongoing trend to make the embedded device to be reusable and reconfigurable. From the hardware perspective, the CPU can be configured at real time. For example, the bit width of the operand can be dynamically changed to reduce the power consumption. There is demand for new embedded operating system to fit into the reconfigurable hardware platform. From the software perspective, the embedded operating system can be divided into two separated parts. One remains unchanged within the embedded system, while the other can be downloaded or upgraded on demand. Embedded Java is going towards this trend.