Embedded systems are computer systems designed to perform specific dedicated functions within a larger system. They are embedded as a part of the complete system, hence the name embedded system.
Development of embedded systems began in the 1960s. Apollo guidance computer and the guidance computer of minuteman missile were perhaps the first modern embedded systems. Since the early applications in the 1960s, embedded systems have grown exponentially in terms of power and functionality. Also, the cost of these systems has come down, due to their large-scale proliferation.
Today, embedded systems span all aspects of modern life ranging from consumer electronics to military systems, medical equipment to telecommunications, industrial equipment to automobiles and so on.
Characteristics of embedded systems
Embedded systems are very different from general-purpose computers. Common characteristics of embedded systems include:
Single function. An embedded system usually executes only one program repeatedly. In contrast, a desktop system executes a variety of programs. As an example, a washing machine always runs the routine of washing clothes, whereas in a desktop computer you can run a variety of programs like MS Office, games and so on.
Interacts with the real world. Embedded systems are usually connected to real-world devices and interact with them through sensors and actuators.
Tightly constrained. Embedded systems have limited resources available in terms of memory, CPU and peripheral input/output (I/O) devices to complete a given job in the desired time. These systems have power constraints also.
Reactive and real-time. Most embedded systems are required to process the data in real time.
Reliability. Embedded systems need to be highly reliable as the implications of failure are much more severe than of desktop systems.
Others. Embedded systems are mostly not standalone devices and are embedded within a larger system. These are supported by a wide array of processors and processor architectures.
The above-mentioned features play a crucial role during the design, development and testing of embedded systems. They also require a host of diverse skill-sets related to hardware, embedded software, electronics and mechanical domains, which renders further complexity to their development.
An embedded system is a combination of computer hardware, software and additional mechanical components designed to perform a dedicated function. The major building blocks of an embedded system include microcontrollers/digital signal processors (DSPs)/field-programmable gate arrays (FPGAs)/system-on-chip (SoC), integrated chips, operating system (including board support package and device drivers), industry-specific protocols and interfaces, and printed circuit board assembly. Usually, an embedded system requires mechanical assembly to accommodate all these components and create the final product or device.
Fig. 1 shows the simplified model of an embedded system. The hardware layer contains all the major physical components and comprises a printed circuit board that accommodates all the semiconductor devices, buses and related electronics. The system and application software layers contain software located on and being processed by the embedded system. Application software layer is the top-most layer comprising the code for a specific application written by developers and utilises services from underlying layers. The system software layer comprises components like device drivers and communication protocols. A special genre of operating systems known as the real-time operating system (RTOS) is usually required to cater to the deadline-driven requirements of an embedded system.
Fig. 2 shows the detailed description of each of the layers discussed above.
Nowadays most embedded designs are configured around 32-bit processors. With the continuing advances in VLSI technology, the trend is towards larger and more powerful processors. The program code and applications running on embedded systems also continue to increase both in complexity and memory requirements. Therefore most of them today have an operating system to manage the hardware and the software resources. ‘C’ family of languages is used for development in majority of embedded systems. Assembly language is still used by many developers, but to write a small portion of their code.
Development of an embedded system therefore requires a host of diverse skill-sets related to hardware, embedded software, electronics and mechanical domains. In a nutshell, with the exponential growth of embedded systems in terms of increased functionality and performance, selection of a particular technology for system development is a tough call for product managers and architects.
As shown in Fig. 3, the design lifecycle of an embedded system can be divided into following phases: Product specification, partitioning the design into hardware and software components, iteration and refinement of partitioning, independent hardware and software design tasks, integration of hardware and software design tasks, product testing and release, and maintenance and upgrading.
The first step in designing an embedded system is the finalisation of product specifications including functional and non-functional requirements. Functional requirements dictate hardware components including the hardware requirements to process input and output signals, external interfaces and I/O devices. Non-functional requirements include the size, cost and power consumption. The product specifications are finalised through detailed interactions with the customer.
Deciding how to partition the design into the functionality that is represented by the hardware and the software is a key part of creating an embedded system. Hardware/software partitioning is done keeping in mind the different constraints including cost, expertise, market competition and so on. After deliberations of the design team members, the functionalities to be implemented in hardware and software are determined.
After partitioning, hardware and software designs are carried out. The hardware team decides the processor and the other peripheral components to be used depending on the desired functionality, processing speed and memory addressing capability. The software team decides the development platform to be used for software development and carries out the design.