Subject Name: Embedded system Design Subject Code: 10EC74

Slides:



Advertisements
Similar presentations
Software Modeling SWE5441 Lecture 3 Eng. Mohammed Timraz
Advertisements

CH02: Modeling the process and life cycle Process of developing software (organization and discipline in the activities) contribute to the quality of the.
Requirements Engineering n Elicit requirements from customer  Information and control needs, product function and behavior, overall product performance,
© 2006 Pearson Addison-Wesley. All rights reserved2-1 Chapter 2 Principles of Programming & Software Engineering.
Software Engineering CSE470: Systems Engineering 35 Computer System Engineering Computer System Engineering is a problem-solving activity. Itemize desired.
S/W Project Management Software Process Models. Objectives To understand  Software process and process models, including the main characteristics of.
Chapter 2 The process Process, Methods, and Tools
CS 360 Lecture 3.  The software process is a structured set of activities required to develop a software system.  Fundamental Assumption:  Good software.
Team Skill 6: Building the Right System From Use Cases to Implementation (25)
Topic (1)Software Engineering (601321)1 Introduction Complex and large SW. SW crises Expensive HW. Custom SW. Batch execution.
SOFTWARE DESIGN (SWD) Instructor: Dr. Hany H. Ammar
High Performance Embedded Computing © 2007 Elsevier Chapter 1, part 2: Embedded Computing High Performance Embedded Computing Wayne Wolf.
Modeling and simulation of systems Model building Slovak University of Technology Faculty of Material Science and Technology in Trnava.
© 2012 xtUML.org Bill Chown – Mentor Graphics Model Driven Engineering.
1 Introduction to Software Engineering Lecture 1.
1 CMPT 275 High Level Design Phase Modularization.
© 2006 Pearson Addison-Wesley. All rights reserved2-1 Chapter 2 Principles of Programming & Software Engineering.
© 2006 Pearson Addison-Wesley. All rights reserved 2-1 Chapter 2 Principles of Programming & Software Engineering.
Architecture View Models A model is a complete, simplified description of a system from a particular perspective or viewpoint. There is no single view.
Software Engineering and Object-Oriented Design Topics: Solutions Modules Key Programming Issues Development Methods Object-Oriented Principles.
Software Engineering1  Verification: The software should conform to its specification  Validation: The software should do what the user really requires.
21/1/ Analysis - Model of real-world situation - What ? System Design - Overall architecture (sub-systems) Object Design - Refinement of Design.
Software Development Process CS 360 Lecture 3. Software Process The software process is a structured set of activities required to develop a software.
 System Requirement Specification and System Planning.
Why is Design so Difficult? Analysis: Focuses on the application domain Design: Focuses on the solution domain –The solution domain is changing very rapidly.
C_ITIP211 LECTURER: E.DONDO. Unit 1 : The Systems Development Environment.
MANAGEMENT INFORMATION SYSTEM
Principles of Programming & Software Engineering
Programmable Logic Devices
Introduction to Systems Analysis and Design
DDC 2223 SYSTEM SOFTWARE DDC2223 SYSTEM SOFTWARE.
Introduction To DBMS.
Chapter 1 The Systems Development Environment
Software Design.
Chapter3:Software Processes
ASIC Design Methodology
Cmpe 589 Spring 2006.
Chapter 1 The Systems Development Environment
Component and Deployment Diagrams
Architecture Concept Documents
Unified Modeling Language
System Design and Modeling
Chapter 1 The Systems Development Environment
The Systems Engineering Context
Lecture 9- Design Concepts and Principles
Software Design Mr. Manoj Kumar Kar.
Software Quality Engineering
Software Requirements
Chapter 1 The Systems Development Environment
Object oriented system development life cycle
CS4101 Introduction to Embedded Systems Design and Implementation
CHAPTER 2 CREATING AN ARCHITECTURAL DESIGN.
Overview of System Engineering
Chapter 5 Designing the Architecture Shari L. Pfleeger Joanne M. Atlee
CS223: Software Engineering
Lecture 9- Design Concepts and Principles
Analysis models and design models
CS 8532: Advanced Software Engineering
An Introduction to Software Architecture
Introduction to Systems Analysis and Design Stefano Moshi Memorial University College System Analysis & Design BIT
CS310 Software Engineering Lecturer Dr.Doaa Sami
CHAPTER 9 (part a) BASIC INFORMATION SYSTEMS CONCEPTS
Embedded Systems Design and Development
Human Computer Interaction Lecture 14 HCI in Software Process
Stumpf and Teague Object-Oriented Systems Analysis and Design with UML
Chapter 1 The Systems Development Environment
Stumpf and Teague Object-Oriented Systems Analysis and Design with UML
From Use Cases to Implementation
DESIGN CONCEPTS AND PRINCIPLES
Presentation transcript:

Subject Name: Embedded system Design Subject Code: 10EC74 Prepared By: Aswini N , M N Praphul & Navya Vipin (TE) Department: ECE Date: 10/11/14 11/17/2018

UNIT 4 11/17/2018

TOPICS COVERED Things to consider in a design Product Life Cycle   TOPICS COVERED Things to consider in a design Product Life Cycle Five steps to design Identifying the Requirements, Formulating the Requirements Specification The System Design Specification, System Specifications versus System Requirements Partitioning and Decomposing a System Functional Design, Architectural Design Functional Model versus Architectural Model Prototyping Achiving the Project

Things to consider in a design When we start thinking about a new product or add new features to an existing one, we need to see many things in detail. The most important is the customer itself. We need to learn about market and technology trade-offs. Old Technlogy New Technology Old Market New Market 11/17/2018

Life Cycle Models The life cycle models in embedded application 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 common life cycle models are:- Waterfall V Cycle Spiral Rapid Prototype 11/17/2018

WATERFALL MODEL 11/17/2018

11/17/2018

11/17/2018

11/17/2018

FIVE STEPS TO DESIGN Requirements Definition System Specification Functional Design Architectural Design Prototyping 11/17/2018

The Design Process Approach is top down and iterative. 1 & 2 steps focus on capturing and formalizing the external behaviour of the system. 3,4 & 5 steps move inside the system and repeat the process for the internal implementation. 11/17/2018

Functional Design Finding an appropriate internal functional architecture for the system. Eg:- Aircraft Design. The top level functional model will consist of 3 major functions- take off, fly and Land. All other sub systems design can be postponed later. Functional description should be written by a knowledgeable person who will do the s/w- h/w development. Successive refinements need to be done after doing the first round functional design. 11/17/2018

11/17/2018

Functional Design Counter Example Identifying the Functions:- Navigation Radio Measurement System User Counter Future Remote Computer Factory Test line Counter User Remote Computer Radio 11/17/2018

Architectural Design Goal is to select the most appropriate solution to the original problems based on exploration of a variety of architectures. Choose the best suited s/w-h/w portioning and allocation of functionality. Map the functions to hardware. Allocation of the different pieces of system functionality to the appropriate hardware and software blocks. 11/17/2018

Architectural Design Constraints that must be included are:- The geographical distribution Physical and user interfaces System performance specifications Timing constraints and dependability requirements Power Consumption Cost 11/17/2018

Hardware software Continuum Hardware Hardware Design Requirements Or Software Software Design 11/17/2018

Hardware Architecture of the Counter Reset Signal to measure Display Counter-divider chain and Control Microprocessor RAM ROM Clock system Front panel controls Power Supply 11/17/2018

Hardware Architecture of the Counter Hardware parts:- Microprocessor Display Front panel controls Power system Clock system (includes s/w also) Software tasks include display task, measurement task, counter- divider chain control block and output task. 11/17/2018

Functional Vs Architectural Model Functional Model- Describes a system through a set of interfacing functional elements. The functional modules will interact using one of the three types of relations:- Shared variable relation Synchronization relation Message transfer by port 11/17/2018

Functional Vs Architectural Model Architectural Model- Describes the physical architecture of the system based on real components such as microprocessors, arrayed logics,SPPs, analog and digital components and the interconnections between them. 11/17/2018

Prototyping Leads to an operational system prototype. Prototype implementation includes:- Detailed design Debugging Validation Testing Prototyping is a bottom-up process. Each level should be validated. 11/17/2018

Prototyping- Static Analyzing Static Analysis should consider three areas:- Coupling- Related to the complexities of relationships that exist among various system modules. Cohesiveness- Measure of the functional homogenity of elements in the modules. Need to consider both external and internal relationships. Complexity- Two types are Functional and Behavioral 11/17/2018

Prototyping- Analyzing Functional Complexity is characterized by:- No. of internal functions and relational components. Keep them small in number. Interconnections among modules. Behavioral Complexity is characterized by:- Number of inputs an outputs. Target is small number. Length and ease of reading and understanding the description of the module. Flow control through the module. 11/17/2018

Prototyping- Dynamic Analyzing Dynamic- determine how system will behave in a context. Dynamic analysis considers the following factors:- Behavioral Verification Performance analysis Trade-off analysis 11/17/2018

Other Considerations Capitalization Essential to the contemporary design process. Proper and Efficient exploitation of Intellectual Properties (IPs). IPs are designs, often patented ,that can be sold to another party to develop and sell their product. 11/17/2018

Other Considerations Reuse It is an activity to be performed during the functional and architectural design phases of the project. To help designers shorten the development life cycle. To be reused, a component needs to be:- Well defined Properly modularized In conformance to some interchange standard. 11/17/2018

Other Considerations Requirements Traceability The ability to follow the life of a requirement (from original specification ) in both forward and reverse directions through the entire design process. Traceability provides many informations like:- Means for the project manager and customer to monitor the development progress. Confirms that the requirement has been faithfully implemented. Means of identifying which h/w and s/w modules are affected, if a requirement changes. 11/17/2018

Other Considerations Requirements Management- It addresses:- Requirement modifications Changes Improvements Corrections A clear procedure that facilitates a way to accommodate modifications has to be used during the whole design process. 11/17/2018

Archiving the Project During the development of the project, a lot of information has been produced and there is need for retaining them. Archiving means documentation of the records. A typical project will have had many contributors:- Product planning Design and Development Test Manufacturing Marketing Sales 11/17/2018

Archiving the Project Each of them will have information, knowledge, documentation and tools That will be important in the future. Project Source Binaries Libraries Data Dictionary Documentation Make Files Tools Specifications A Typical project software Directory 11/17/2018

Archiving the Project Each of the groups participating in the development should have similar directory documenting their portion of the project. If the source code or the ability to rebuild from sources is lost, future work on the project will be seriously affected. All the s/w tools like CAD, CAM, FPGA modeling tool have product life cycle and need to be modified and updated. So archiving (documenting) the complete developing environment- computer, hard drive, OS and so on is worth considering. 11/17/2018