Issues in embedded system design

• Choosing Right platform

• Embedded system processor choice
• Factors and needed features taken into
consideration
• Hardware software tradeoff
 System Integration
• The task of creating a properly functioning system from
its constituent components
– Hardware
– Firmware
– Software
• System Hardware Integration
– Are the components wired together correctly?
• System Software Integration
– Typically assumes hardware integration is largely complete
– The final step before acceptance testing and deployment
Traditional Design Flow
 Co-design of Processors
• General-Purpose Processors
– Architectural support for operating systems.
– Cache design and tuning (e.g., selection of cache size
and control schemes).
– Pipeline control design (control mechanisms, compiler
design).
• ASIPs
– Customization of instruction sets and specific
resources (e.g., accelerator and coprocessor).
– Design of register files, buses and interconnections.
– Development of specific compiler.
Issues in Hardware Software co-design
• Selecting the model
• Models are used for capturing and describing the system
characteristics.
• Selecting the architecture
• The achitecture specifies the how a system is going to implement in
terms of number and types of different components and
interconnect among them.
• Selecting the language
• A programming language captures a computational model and
maps it into architecture.
• A model can be captured using mulpiple programming languages
like C,C++, java etc for software implementations and languages like
VHDL, Verilog, System C, etc. for hardware implementations.
• Partitioning system requirements into Hardware and Software
 Computational models in embedded
Design
• Data flow graph/diagram (DFG) model
• Control data flow graph/diagram (CDFG)
• State machine model
What is Embedded product Design Life Cycle (EDLC)?
➢ EDLC is an Analysis-Design-Implementation
based problem solving approach for the
product development.

▪ Analysis – What product need to be

developed
▪ Design – Good approach for building it
▪ Implementation – To develop it
Why EDLC?
• Essential in understanding the scope and
complexities involved in any Embedded product
development.
• Defines interaction and activities among
Various groups of product development sector.
• Project management
• System design and development
• System testing
• Release management and quality assurance
 DIFFERENT PHASES OF EDLC
• The following figure depicts the different
phases in EDLC:
• Need
– The need may come from an individual or from the
public or from a company.
– ‘Need’ should be articulated to initiate the
Development Life Cycle; a ‘Concept Proposal’ is
prepared which is reviewed by the senior
management for approval.
• Need can be visualized in any one of the
following three needs:
– New or Custom Product Development.
– Product Re-engineering.
– Product Maintenance.
• Conceptualization
– Defines the scope of concept, performs cost benefit analysis
and feasibility study and prepare project management and
risk management plans.
• The following activities performed during this phase:
– Feasibility Study : Examine the need and suggest possible
solutions.
– Cost Benefit Analysis (CBA): Revealing and assessing the
total development cost and profit expected from the
product.
– Product Scope: Deals with the activities involved in
the product to be made.
– Planning Activities: Requires various plans to be developed
first before development like Resource Planning & Risk
management Plans.
• Analysis
– The product is defined in detail with respect to the inputs, processes,
outputs, and interfaces at a functional level.
• The various activities performed during this phase..
– Analysis and Documentations: This activity consolidates the business
needs of the product under development.
– Requirements that need to be addressed..
• Functional Capabilities like performance
• Operational and non-operational quality attribute
• Product external interface requirements
• Data requirements User manuals
• Operational requirements
• Maintenance requirements
• General assumptions
– Defining Test Plan and Procedures: The various type of testing
performed in a product development are:
• Unit testing – Testing Individual modules
• Integration testing – Testing a group of modules for required functionality
• System testing- Testing functional aspects or functional requirements of the
product after integration
• User acceptance testing- Testing the product to meet the end user
requirements.
• Design
– The design phase identifies application environment
and creates an overall architecture for the product.
– It starts with the Preliminary Design. It establishes the
top level architecture for the product. On completion
it resembles a ‘black box’ that defines only the inputs
and outputs. The final product is called Preliminary
Design Document (PDD).
– Once the PDD is accepted by the End User the next
task is to create the ‘Detailed Design’.
• Development and Testing
– Development phase transforms the design into a
realizable product.
– The detailed specification generated during the design
phase is translated into hardware and firmware.
– The Testing phase can be divided into independent
testing of firmware and hardware that is:
– Unit testing
– Integration testing
– System testing
– User acceptance testing
• Deployment
– Deployment is the process of launching the first fully functional model of
the product in the market.
– It is also known as First Customer Shipping (FCS).
• Tasks performed during this phase are:
– Notification of Product Deployment: Tasks performed here include:
• Deployment schedule
• Brief description about the product
• Targeted end user
• Extra features supported
• Product support information
– Execution of training plan Proper training should be given to the end
user top get them acquainted with the new product.
– Product installation
• Install the product as per the installation document to ensure that it is fully
functional.
– Product post Implementation Review
• After the product launch, a post implementation review is done to test the
success of the product.
• Support
– The support phase deals with the operational and
maintenance of the product in the production
environment.
– Bugs in the product may be observed and reported.
– The support phase ensures that the product meets the
user needs and it continues functioning in the production
environment.
– Activities involved under support are
– Setting up of a dedicated support wing: Involves providing
24 x 7 supports for the product after it is launched.
– Identify Bugs and Areas of Improvement: Identify bugs
and take measures to eliminate them.
• Upgrades
– Deals with the development of upgrades (new versions) for the
product which is already present in the market.
– Product upgrade results as an output of major bug fixes.
– During the upgrade phase the system is subject to design
modification to fix the major bugs reported.
• Retirement/Disposal
– The retirement/disposal of the product is a gradual process.
– This phase is the final phase in a product development life cycle
where the product is declared as discontinued from the market.
– The disposal of a product is essential due to the following
reasons
– Rapid technology advancement
– Increased user needs
 Life Cycle Models
• The product life cycle of an embedded application
is purely a descriptive representation.
• It breaks the development process into a series of
interrelated activities.
• Each activity plays a role of transforming its input
(specification) into an output (a selected solution).
• The organization of the steps is done according to
a design process model – the life cycle model.
• Formality in design provides the structure for a
development that lets one creatively explore the
design while using the tools to manage some of
the more mechanical issues.
• The fundamentals of design are:
– Find out what the customers want.
– Think of a way to give them what they want.
– Prove what you have done by building and testing it.
– Build a lot of the product to prove that it wasn‘t an
accident.
– Use the product to solve the customer‘s problem.
• The common life cycle models are:
– Waterfall
– V Cycle
– Spiral
– Rapid Prototype
 Embedded software development Tools
• "Embedded software" is the software that is embedded
in an electronic product to control its operation.
• Embedded software developers need embedded
software development tools to develop embedded
software.
• An embedded software development environment is an
integrated collection of software development tools that
manage the entire embedded software development
process: analyzing, designing, documenting, writing,
compiling, debugging, testing, optimizing, and verifying
software.
 Host and Target Machines
• Introduction:
– Many embedded systems employ microprocessors or
microcontrollers intimately bound into dedicated
equipment. Such systems require a special approach to
software development.
– The target system is not often capable of supporting
the editors, compilers, linkers, debugging and code
control tools essential for the development task. So, a
larger computer is used for the actual code production.
• This is the host platform and is commonly a desktop PC
running Windows or a version of Unix.
• In this way all the hardware and software facilities of a larger
computer system can be utilized during the development
process.
 Host and Target Machines
• If the selected target system has a different CPU to that in
the host computer, The executable code built on the host
machine can’t be run on the target machine.
• Most of the time host and target machines differ so that
programs built on the host machine can’t be run on the
target machine. These differences may take many forms.
• Some common differences between host and target
machines are:
– different operating system
– different system boards
– different processor.
• Additional problems occur with the need for cross-
compilers and associated target libraries.
• The host file system has to be carefully organized so as to
keep the native and cross-compilers and libraries well apart.
 Host Machine
• A typical, general purpose computer or
workstation used for:
– Programming
– compiling
– (testing/emulation)
• Vast computing resources
– support sophisticated IDEs
– compilers and debugging environments.
• Where the embedded software is developed,
compiled, tested, debugged, optimized, and prior
to its translation into target device.
 Target machine
• The Target machine is the embedded Hardware platform
• Target hardware consists of
– processor, memory, I/O
– Runtime environment (Operating System/Kernel)
– Target hardware platform contains only what is needed for
final deployment
– Target hardware platform does not contain development
tools (editor, compiler, debugger)
– Special purpose
• selected and supports:
– Testing
– Integration
– execution
– Deployment
 Host and Target Machines
• Host: computer where tools are run „
• Target: processor you are shipping „
• Native tools – run on the host „
– Compilers
– Assemblers
– E.g. Windows NT compiler produces binary Pentium instructions (great
for Pentium, worthless for Motorola 68000) „
• Cross-Compilers „
– Runs on your host, but produces binary instructions for your target from
your C/C++ programs. „
• Cross-Assemblers „
– Runs on your host, but produces binary instructions for your target from
your assembly programs. „
• Tool Chains „
– Named because output of one tool becomes the input for the next tool „
– Tools compatible with a particular target are called a “Tool Chain” and
are available from different vendors.
 Software Tools
• Software Development kit (SDK)
• Source-code Engineering Software tool
• Integrated Development Environment
• Editor
• Interpreter
• Testing and debugging tools
• Locator
 Software development kit (SDK)
• A software development kit (SDK or devkit) is typically a set of
software development tools that allows
– the creation of applications for a certain software package, software
framework,
– hardware platform,
– computer system,
– video game console,
– operating system, or similar development platform.
• It may be something as simple as the implementation of one or more
application programming interfaces (APIs) in the form of
some libraries to interface to a particular programming language or
to include sophisticated hardware that can communicate with a
particular embedded system.
• Common tools include debugging facilities and other utilities.
 Source Code Engineering Tool
• Typical tool Features Typical tool Features
– Comprehension, Navigation and browsing.
– Editing, Debugging,
– Configuring (disabling and enabling specific C++
features) and Compiling.
– Searches and lists the definitions, symbols, hierarchy
of the classes, and class inheritance trees.
– Symbols include the class members.
– Searches and lists the dependencies of symbols and
defined symbols, variables and functions.
Integrated Development Environment (IDE)
• An integrated development environment (IDE) is a
software suite that consolidates the basic tools,
developers need to write and test software.
• In embedded system development context, IDE stands
for an integrated environment for developing and
debugging the target processor specific embedded
firmware.
• Typically, an IDE contains a code editor, a cross-compiler
or interpreter, linker and a debugger that the developer
accesses through a single graphical user interface (GUI).
• Some IDEs may provide interface to Target board
emulators, Target flash memory programmer.
• An IDE may be a standalone application, or it may be
included as part of one or more existing and compatible
applications.
• IDEs are typically designed to integrate with third-party
version control libraries, like GitHub or Apache Subversion.
• IDEs used in embedded firmware development slightly
different from the generic IDEs used for high level language
based development for desktop applications.
• In embedded applications, the IDE is either supplied by
target manufacturer or by third party vendors as open
source.
• Some commonly used IDEs for embedded systems are:
– The GNU compiler (gcc),
– Eclipse (open source IDE)
– Android Studio,
– Keil µ vision (third party IDE )
– Code warriors by Metrowerks for ARM family of controllers.
– MPlab (supplied by Microchip for PIC family controllers)
 Editor
• A source code editor is a text editor program
designed specifically for editing source code to
control embedded systems.
• The code editor allows code to be written, changed
and saved as files in folders called project folder.
• It may be a standalone application or it may be
built into an integrated development environment
(e.g. IDE).
• Source code editors may have features specifically
designed to simplify and speed up input of source
code, such as syntax highlighting and auto
complete functionality.
 Compiler
• A compiler is a computer program that translates the
source code into computer (Target) language (object
code).
• Commonly the output has a form suitable for
processing by other programs (e.g., a linker), but it may
be a human-readable text file.
• A compiler translates source code from a high level
language to a lower level language (e.g., assembly
language or machine language).
• The most common reason for wanting to translate
source code is to create a program that can be
executed on a computer or on an embedded system.
 Cross Compiler
• A cross compiler is a compiler capable of creating object
code (Target language) for a platform other than the one
on which the compiler is running.
• For example, a compiler that runs on a Windows 7 PC
but generates code that runs on Android Smartphone is
a cross compiler.
• For embedded systems the compiler always runs on
another platform, so a cross compiler is needed.
• A cross compiler is a tool that one must use for a
platform where it is inconvenient or impossible to
compile on that platform, like micro controllers that run
with a minimal amount of memory for their own
purpose.
• Since many embedded systems have limited resources,
cross-compiling is very common.
• Assembler
– An assembler is a program that converts assembly
language into machine code.
– It takes the basic commands and operations from
assembly code and converts them into binary code that
can be recognized by a specific type of processor.
• Cross Assembler
– A cross assembler is a program which generates
machine code for a processor other than the one it is
currently run on.
– Cross assemblers are generally used to develop
programs which are supposed to run on game consoles,
appliances and other specialized embedded systems
which are not able to run a development environment.
 Interpreter
• An interpreter is a computer program that
translates a program line-by-line (statement-by-
statement) and carries out the specified actions
in sequence.
– In contrast, an assembler or compiler completely
translates a program written in a high-level
language (the source code) into a machine-language
program (the object code) for later execution.
– Whereas a compiled-program executes much faster
than an interpreted-program, an interpreter allows
examination and modification of the program while
it is running (executing).
 The embedded
software
development
process

Tool chain for building embedded software

 Linker
• A linker is a program that takes one or more objects generated by
compilers and assemblers and combine them into a single executable
program or a library that can later be linked to in itself.
• All of the object files resulting from compiling must be combined in a
special way before the program can be executed.
• The object files themselves are individually incomplete, most notably is
that some of the internal variable and function references have not yet
been resolved.
• The job of the linker is to combine these object files and, in the
process, to resolve all of the unresolved symbols.
• Linkers can take objects from a collection called a library. Some linkers
do not include the whole library in the output. They only include its
symbols that are referenced from other object files or libraries.
• Libraries for diverse purposes exist, and one or more system libraries
are usually linked in by default.
• The Linker combines object files (from compiler) and
resolves variable and function references
– Source code may be contained in >1 file, which must be
combined
– Resolve variables which may be referenced in one file and
defined in another file
– Resolve calls to library functions, like sqrt
– May include operating system
• Linker creates a “relocatable” version of the program
– Program is complete, except no memory addresses
assigned
 Locator
• The tool that performs the conversion from
relocatable program to executable binary image is
called a locator.
• It takes responsibility for the easiest step of the
build process.
– we have to provide information about the memory on
the target board as input to the locator.
• The locator uses information (Target memory as
input) to assign physical memory addresses to
each of the code and data sections.
• It will produce an output file that contains a binary
image that can be loaded into the target ROM.
• Functions performed by locator, normally left for
operating systems:
– address binding
– Determines what goes in ROM and what goes in RAM
– Divide program into appropriate number of segments
and assign to appropriate memory types
– I/O routine inclusion
– Assign startup code to designated address on
controller
– Range of addresses for ROM and RAM
– Desired location for different modules
Intel Hex File Format
 Getting Software Into Target
• The locator will build a file as an image for the
target software.
• There are few ways to getting the embedded
software file into target system.
– PROM programmers - actual ROM „
– ROM emulators - hardware thinks it’s a ROM „
– In-circuit emulators - replaces entire processor on
hardware board „
– FLASH - if target stores program separately „
– Monitors - program in target to receive program
- for debugging mainly