Embedded development life cycle

The design of an embedded system implies that both software and hardware are being
designed in parallel.

Figure1: embedded design life cycle diagram

A phase representation of embedded design life cycle
Time flows from left and proceeds through seven phases:

Product specification
Partitioning of design into its software and hardware components
Iteration and refinement of the partitioning
Independent hardware and software design tasks
Integration of the hardware and software components
Product testing and release
On-going maintenance upgrading

The embedded design process is not as simple as figure1 depicts. A considerable

amount of iteration and optimization occurs within phases and between phases.Defects
found in later stages often cause us to go back. For example, when product testing
reveals performance deficiencies that render the design noncompetitive, we might have to
rewrite algorithms, redesign custom hardware-such as application specific integrated
circuits(ASICs) for better performance-speed up the processor, choose a new processor,
and so on.

Product specifications:
Design of any system starts at its specifications, specifications uses a language,
which may be simple English, some programming languages like C, or it may be some
formal techniques using petri nets, state chart and so on.
The choice of the microprocessor and some other key elements of a design are
important

Hardware/software partitioning:
Embedded design involve both hardware and software components, we have to
decide which portion of the problem will be solved in hardware and which in software.
This choice is called the partitioning decision.
A general purpose processor will have software implementation of the task, while
a dedicated processor can be implemented on FPGA(field programmable gate array) or
ASIC(application specific integrated circuit), to have better performance
`The partitioning decision is a complex optimization problem. Many embedded
designs are required to be

Price sensitive
Leading edge performers
Non standard
Market competitive
Proprietary

Iteration and implementation:

The iteration and implementation part of the process represents a somewhat
blurred area between implementation and hardware/software partitioning in which the
hardware and software paths diverge. This phase represents the early design work before
the hardware and software teams built the wall between them.
The hardware designers might be using simulation tools such as architectural
simulators, to model the performance of the processor and memory systems. The

software designers are probably running code bench marks on self-contain single board
computers that use the target microprocessors.

Detailed hardware and software design:

Hardware design involves

Selection of the processor: micro-controller, microprocessor, digital

signal processor
Calculation of memory requirements and the type of memory such as
RAM(SRAM,DRAM), EPROM, flash memory
Identification of input devices such as sensors, keyboard and keypad
Identification of output devices such as LEDs and LCD
Identification of communication interfaces such as RS232, Ethernet,
USB
Identification of test points
Identification of supply voltages and current requirements for designing
the power supply unit.

Software design involves

Working out of the details of the processing to be done by the embedded

system
Decomposition of the processing into different task
Deciding on the use of an embedded operating system

Hardware/Software integration:
The hardware/software integration phase of the development cycle must have
special tools and methods to manage the complexity. The process of integrating
embedded software and hardware is exercise in debugging and discovery
Debugging an embedded system:
Debugging an embedded system is similar to debugging a host based
applications. If the target system contains an available communication channel to the host
computer, the debugger can exist as two pieces: a debug kernel in the target system and a
host application that communicates with it and manages the source database and symbol
tables. Many embedded systems are impossible to debug unless they are operating at full
speed. Running an embedded program under a debugger can slow the program down by
one or more orders of magnitude.
In general, there are three requirements for debugging an embedded or
real-time system:

Run control- the ability to start, stop, peak, and poke the processor and
memory.
Memory substitution- replacing ROM-based memory with RAM for
rapid and easy code download, debug, and repair cycles.
Real-time analysis- following code flow in real time with real-time trace
analysis

Product testing and release:

Testing is the most difficult and time consuming process and important process.
Testing is the process to reduce the risk associated with the residual defects.
There are different types of testing
Black box testing: Functionality of the product is tested
White box testing: each and every line of code is tested
Performance testing: checks whether the system is meeting the time constraintsas per the
requirements

Maintenance and upgrading:

Reliability: The measure of how much percentage the system can rely upon
theproper functionality of the system.
MTBF(Mean time between failures) and MTTR (mean time to reapair) are the
terms used in defining system reliability
Maintainability: It deals with support maintenance in case of technical issues and
product failure.
As the reliability of the system increases the chances of failure reduces, then the
maintainability also reduces.
The ideal value of availability of any embedded system design is
Ai=MTBF/(MTBF+MTTR)