BM 3551 – EMBEDDED

SYSTEMS AND IOT

UNIT 1 : INTRODUCTION TO EMBEDDED

SYSTEM DESIGN

Topic : Categories of Embedded Systems, Embedded

System design, Challenges in Embedded System design

Ms. S. Indu
AP / BME
Categories of Embedded Systems
Embedded Systems are classified based on the two factors i.e.,
I. Performance and Functional Requirements
II. Performance of Micro-controllers
I. Based on Performance and Functional Requirements it is divided into 4
types as follows :

1.Real-Time Embedded Systems : A Real-Time Embedded System is strictly

time specific which means these embedded systems provides output in a
particular/defined time interval. These type of embedded systems provide quick
response in critical situations which gives most priority to time based task
performance and generation of output.

Examples :
o Traffic control system
o Military usage in defense sector
o Medical usage in health sector
Real Time Embedded System is divided into two types i.e.
 Soft Real Time Embedded Systems – In these types of embedded systems
time/deadline is not so strictly followed. If deadline of the task is passed
(means the system didn‘t give result in the defined time) still result or output
is accepted.
 Hard Real-Time Embedded Systems – In these types of embedded systems
time/deadline of task is strictly followed. Task must be completed in between
time frame (defined time interval) otherwise result/output may not be
accepted.

2.Stand Alone Embedded Systems : Stand Alone Embedded Systems are

independent systems which can work by themselves they don‘t depend on a host
system. It takes input in digital or analog form and provides the output.

Examples :
o MP3 players
o Microwave ovens
o Calculator
3. Networked Embedded Systems : Networked Embedded Systems are connected
to a network which may be wired or wireless to provide output to the attached
device. They communicate with embedded web server through network.

Examples :
o Home security systems
o ATM machine
o Card swipe machine

4. Mobile Embedded Systems : Mobile embedded systems are small and easy to
use and requires less resources. They are the most preferred embedded systems.
In portability point of view mobile embedded systems are also best.

Examples :
o MP3 player
o Mobile phones
o Digital Camera
II. Based on Performance and micro-controller it is divided into 3 types as
follows :

1. Small Scale Embedded Systems : Small Scale Embedded Systems are

designed using an 8-bit or 16-bit micro-controller. They can be powered by a
battery. The processor uses very less/limited resources of memory and
processing speed. Mainly these systems does not act as an independent
system they act as any component of computer system but they did not
compute and dedicated for a specific task.
2. Medium Scale Embedded Systems : Medium Scale Embedded Systems are
designed using an 16-bit or 32-bit micro-controller. These medium Scale
Embedded Systems are faster than that of small Scale Embedded Systems.
Integration of hardware and software is complex in these systems. Java, C, C++
are the programming languages are used to develop medium scale embedded
systems. Different type of software tools like compiler, debugger, simulator etc
are used to develop these type of systems.

3. Sophisticated or Complex Embedded Systems : Sophisticated or Complex

Embedded Systems are designed using multiple 32-bit or 64-bit micro-controller.
These systems are developed to perform large scale complex functions. These
systems have high hardware and software complexities. We use both hardware
and software components to design final systems or hardware products.
 Embedded System Design
The design process for embedded systems is an iterative journey that
transforms an idea into a functioning product. Designing an embedded
system involves several stages, including requirements gathering,
specification, design, implementation, testing, and maintenance.

1. Requirements Gathering:
This is the foundation. We need to define what the embedded system will
do and how it will perform.

Functional Requirements:
• Use cases: Identify typical scenarios where the system will be used.
• Functionalities: List specific functions the system must perform (e.g.,
data processing, communication protocols).
• Performance: Specify expected response times, throughput, and
reliability
Non-Functional Requirements:
• Constraints: Include limitations such as size, power consumption, and cost.
• Reliability: Specify uptime requirements and mean time between failures
(MTBF).
• Environmental Conditions: Consider factors like temperature range,
humidity, and shock resistance.
• Regulatory Compliance: Ensure adherence to relevant standards and
regulations (e.g., safety standards).

2. Specification Development:
Based on the requirements, you create a detailed technical document. This
document serves as a blueprint for the design and acts as a contract between
different stakeholders (designers, developers, etc.).

The specification should include:

 System Architecture: A high-level overview of the hardware and software
components and how they interact.
 Hardware Selection: Detailed specifications for processors, memory,
sensors, and other hardware components.
  Software Design: Functional breakdown of the software modules and
their communication protocols.
 Interface Definitions: How different components (hardware and
software) will communicate with each other.
 Testing Procedures: Methods for verifying that the system meets the
requirements.

3. Design and Development:

With the specification in hand, the actual design and development phase begins.
This involves:
 Hardware Design: Selecting or designing the hardware components
based on the chosen architecture. This may involve circuit design, board
layout, and component integration.
 Software Development: Writing the code for different software modules
according to the specifications. This includes coding for device drivers,
data processing algorithms, and user interface elements.
 System Integration: Connecting the hardware and software components to
create a functional system. This may involve writing code to manage
communication between them.

4. Testing and Verification:

This phase ensures the system performs as intended. It involves multiple stages:
 Unit Testing: Testing individual hardware components and software
modules in isolation.
 Integration Testing: Verifying how the integrated system functions with
all components working together.
 System Testing: Evaluating the complete system against the defined
requirements. This may involve functional testing, performance testing,
and environmental testing.
5. Iteration and Refinement:
The design process is rarely linear. Based on testing results, you may need to
revisit earlier stages and refine the design. This might involve:
 Hardware modifications: Changing components or adjusting their
configuration.
 Software updates: Fixing bugs, optimizing code, or adding new features.
 Retesting: Verifying the effectiveness of the changes made.

6. Documentation:
Clear and thorough documentation is crucial throughout the process.This
includes:
 Design documents: Capture design decisions, component choices, and
justifications for those choices.
 User manuals: Provide instructions for operating and maintaining the
system.
 Schematics and datasheets: Detailed information about the hardware
components.
 Source code documentation: Explain the functionality of different
software modules.
 Challenges in Embedded System Design
• Non-recurring cost : The one-time monetary cost of designing the system.
Once the system is designed, any number of units can be manufactured
without incurring any additional design cost; hence the term nonrecurring.

• Unit cost : The monetary cost of manufacturing each copy of the system,
excluding NRE cost.

• Size : The physical space required by the system, often measured in bytes for
software, and gates or transistors for hardware.

• Performance : Embedded systems typically have limited processing power,

memory (RAM and storage), and power compared to a PC. This means tasks
that seem simple on a desktop computer can be sluggish or even impossible
on an embedded system. Programmers need to write very efficient code and
carefully manage resources to achieve desired performance.
• Power : The amount of power consumed by the system, which may
determine the lifetime of a battery, or the cooling requirements of the IC,
since more power means more heat.

• Flexibility : The ability to change the functionality of the system without

incurring heavy NRE cost. Software is typically considered very flexible.

• Time to prototype : The time needed to build a working version of the

system, which may be bigger or more expensive than the final system
implementation, but it can be used to verify the system's usefulness and
correctness and to refine the system's functionality.

• Time-to-market: The time required to develop a system to the point that it

can be released and sold to customers. The main contributors are design
time, manufacturing time, and testing time.
 Time-to-market :
(a) Market window
(b) Simplified revenue
model for computing
revenue loss from
delayed entry

• Maintainability : The ability to modify the system after its initial release,
especially by designers who did not originally design the system.

• Correctness : Our conidence that we have implemented the system's

functionality correctly. We can check the functionality throughout the process
of designing the system, and we can insert test circuitry to check that
manufacturing was correct.

• Safety : Security threats are on the rise, and even tiny embedded systems can be
vulnerable. Designers need to build in security features to protect the device
and the data it handles, while also keeping power consumption and processing
power in mind.