Embedded System Design – Formal Definition:
Embedded system design is the process of integrating hardware and software components into a single system that is dedicated to performing a specific function or set of functions within a larger application. It involves abstraction, architectural planning, modular design, mapping of tasks, user interface design, and refinement to meet functional and non-functional requirements such as cost, size, performance, power consumption, safety, and maintainability.

Design of Embedded Systems

Definition:
Embedded system design is the process of embedding hardware and software together to perform a specific function within a larger system. A microcontroller, often based on Harvard architecture, plays a vital role in embedded systems as it integrates processing, memory, and I/O control.

Complete Design of Embedded System

The design of embedded systems involves several steps and concepts:

Abstraction:
The system problem is first abstracted into smaller parts for better understanding. Partitioning of functions into interacting modules is done.
Hardware–Software Architecture:
Before starting design, proper knowledge of both hardware and software is required. Functions are allocated either to hardware units or software modules.
Extra Functional Properties:
Non-functional features like performance, power, and safety must be understood apart from the main design.
System-Related Family of Design:
Existing or previous system designs can be referred to for improvements and compatibility.
Modular Design:
The design must be divided into independent modules with standard interfaces. This allows customization, upgradation, reuse, and easier maintenance.
Mapping:
Mapping is done between software requirements and hardware implementation. For example, data flow and program flow are mapped onto components.
User Interface Design:
The interface is designed as per user requirements and environmental analysis.
Example: In a mobile phone, power consumption can be reduced by optimizing interface parameters. In a vending machine, LCD display serves as the user interface.
Refinement:
Each component and module must be refined so that the software team clearly understands it. Architectural description languages (e.g., VHDL, Verilog) are often used.

Control Hierarchy in Design

Partition of structure
Data structure and hierarchy
Software procedures

Design Flow of Embedded Systems

Requirement: Understanding what the customer wants.
Specification: Precise description of system functions and constraints (functional and non-functional).
Architecture: Block diagram defining system structure (hardware + software).
Component Design: Designing hardware (CPU, peripherals, boards) and software modules.
System Integration: Assembling and testing all modules. Bugs are removed by debugging methods.
Verification & Testing: Ensuring the system meets the original specifications.

Design methods:

Top-Down Methodology: Starts from overall system, breaking into smaller subsystems. Allows customization but difficult metric estimation.
Bottom-Up Methodology: Starts from basic components, building upwards. Allows accurate metrics but requires standard libraries.

Requirements of Embedded Systems

Functional Requirements: Define what the system should do (e.g., services, outputs, inputs).
Non-Functional Requirements: Define constraints like performance, cost, size, weight, and power consumption. These may influence functional requirements.

Example: In GPS moving map system – functions include map scrolling, inputs include buttons, non-functional requirements include power-up time and cost.

Design Metrics / Parameters of Embedded Systems

Design metrics evaluate the quality and efficiency of an embedded system:

NRE Cost (Non-Recurring Engineering Cost): One-time design cost.
Unit Cost: Cost of manufacturing each copy.
Size: Defined in terms of memory (RAM/ROM/Flash) or physical area.
Performance: Measured by execution time or throughput.
Power Consumption: Determines battery life and heat dissipation.
Flexibility: Ability to modify system functions without high cost.
Time-to-Prototype: Time required to build a working model.
Time-to-Market: Total time to develop, test, and launch the product.
Maintainability: Ease of modifying the system after release.
Correctness: Ensuring the system functionality is implemented correctly.
Safety: Protection against failures (e.g., phone lock, automotive engine safety).

Need for RTOS in Embedded Systems

Meeting strict deadlines
Deterministic behavior
Efficient memory and processor usage
Task prioritization
Minimum interrupt latency
Watchdog timer & vectored interrupt handling
Small footprint
Reliable and real-time system performance

Challenges in Embedded System Design

Increasing application and system complexity
Numerous constraints (cost, power, timing, dependability)
Reduced and overlapping design cycles
Limited observability and debugging tools
Restricted development environment
Complex testing as systems often cannot be separated from the machine