Таблица | Карточка | RUSMARC | |
Разрешенные действия:
Группа: Анонимные пользователи Сеть: Интернет |
Аннотация
With this book, you will learn the fundamentals of developing a real-time system. The book relies heavily on diagrams to make the learning process easier and more interesting for you.
Права на использование объекта хранения
Место доступа | Группа пользователей | Действие | ||||
---|---|---|---|---|---|---|
Локальная сеть ИБК СПбПУ | Все |
![]() ![]() ![]() |
||||
Интернет | Авторизованные пользователи СПбПУ |
![]() ![]() ![]() |
||||
![]() |
Интернет | Анонимные пользователи |
Оглавление
- Cover
- FM
- Copyright
- Table of Contents
- Preface
- Chapter 1: Real-Time Systems – Setting the Scene
- 1.1 Categorizing Computer Systems
- 1.2 Real-Time Computer Systems
- 1.2.1 Time and Criticality Issues
- 1.2.2 Real-Time System Structures
- 1.2.3 Characteristics of Embedded Systems
- 1.3 The Computing Elements of Real-Time Systems
- 1.3.1 Overview
- 1.3.2 General-Purpose Microprocessors
- 1.3.3 Highly Integrated Microprocessors
- 1.3.4 Single-Chip Microcomputers
- 1.3.5 Single-Chip Microcontrollers
- 1.3.6 Digital Signal Processors
- 1.3.7 Mixed-Signal Processors
- 1.3.8 System-On-Chip Designs – Overview
- 1.3.9 Programmable SOCs – FPGA-Embedded Processors
- 1.3.10 SOC Devices – Single and Multicore
- 1.4 Software for Real-Time Applications – Some General Comments
- 1.5 Review
- 1.6 Useful Reading Material
- Chapter 2: The Search for Dependable Software
- 2.1 What Do We Want in Our Software?
- 2.2 Software Errors
- 2.2.1 Overview
- 2.2.2 System Design Errors
- 2.2.3 Design and Coding Errors
- 2.2.4 Environmental Factors
- 2.2.5 Why Do We Get Poor Software?
- 2.2.6 Testing – How Useful?
- 2.3 The Basics of Good Software
- 2.3.1 General
- 2.3.2 Specification Correctness
- 2.3.3 Feasibility and Suitability
- 2.3.4 Modularization
- 2.3.5 Portability and Reusability
- 2.3.6 Error Avoidance and Defensive Programming – Robust Programs
- 2.3.7 Design Codes of Practice – Style, Clarity, and Documentation
- 2.4 A Final Comment
- 2.5 Review
- 2.6 References
- Chapter 3: First Steps – Requirements Analysis and Specification
- 3.1 The Software Life Cycle
- 3.1.1 Introduction
- 3.1.2 A Mythical Model of the Software Life Cycle
- 3.1.3 Bringing Realism to the Life Cycle
- 3.1.4 Requirements Issues – a Practical Approach
- 3.2 The Importance of the Requirements Stage
- 3.3 Making Mistakes – Sources and Causes
- 3.3.1 A General Comment
- 3.3.2 Problems in Formulating Specifications
- 3.3.3 Problems in Communicating Requirements
- 3.3.4 Problems in Understanding Requirements
- 3.4 Practical Approaches to Analysis and Specification
- 3.4.1 General Aspects
- 3.4.2 Tool Support and Automation
- 3.4.3 Viewpoint Analysis
- 3.4.4 Viewpoints – Analysis versus Specification
- 3.4.5 Use Case Analysis
- 3.4.6 Functional, Non-Functional, and Development Requirements Specifications
- 3.5 Communication Aspects – the Role of Prototyping
- 3.5.1 Prototyping – an Introduction
- 3.5.2 Software Prototyping
- 3.5.3 Requirements Prototyping
- 3.5.4 Practical Rapid Prototyping of System Requirements
- 3.5.5 Animation Prototyping – Concepts and Application
- 3.6 Review
- 3.7 Exercises
- 3.8 References and Further Reading
- 3.1 The Software Life Cycle
- Chapter 4: Software and Program Design Concepts
- 4.1 Design Fundamentals
- 4.1.1 The Design and Development Process – an Introduction
- 4.1.2 Fundamental Design Strategies
- 4.1.3 How to Generate Abysmal Software – the Good Kludge Guide
- 4.2 The Elements of Modular Design
- 4.2.1 Introduction
- 4.2.2 Modules and Modularization
- 4.2.3 Coupling – a Measure of Module Independence
- 4.2.4 Cohesion – a Measure of Module Binding
- 4.2.5 Size and Complexity
- 4.2.6 Some General Comments on Modules
- 4.3 Program Control Structures – the Influence of Structured Programming
- 4.3.1 Introductory Comments
- 4.3.2 Fundamental Control Structures
- 4.3.3 Uncontrolled Branching of Control – the Great GOTO Debate
- 4.4 Structured Software Designs
- 4.4.1 Background
- 4.4.2 Problem Decomposition Using Abstract Machines
- 4.4.3 Example Implementation
- 4.5 Object-Oriented Design
- 4.5.1 An Introduction
- 4.5.2 Object-Oriented Design – the Identification Process
- 4.5.3 Relationships and Communication between Objects
- 4.5.4 Object Interfaces
- 4.5.5 Object-Oriented Design – Implementation-Related Issues
- 4.5.6 Reuse and Runtime Flexibility Issues
- 4.5.7 Composite Objects – Aggregation
- 4.5.8 Devising the Object Model – a Responsibility-Based Technique
- 4.6 Functionally Structured Design and Functional Flow Modeling
- 4.6.1 Software Design and Structured Charts – Limitations
- 4.6.2 The Materials Flow Model of Software Processing
- 4.6.3 Software Design Using Functionally Structured Techniques
- 4.6.4. Organizing the Execution Sequence of the Software Machines
- 4.6.5 Functional Flow Design Using Graphical Techniques
- 4.7 Design Patterns
- 4.7.1 Introduction and Basic Concepts
- 4.7.2 Program-Level Patterns
- 4.7.3 System-Level Patterns for Real-Time Embedded Systems
- 4.8 Review
- 4.9 Exercises
- 4.10 Useful Reading Material
- 4.1 Design Fundamentals
- Chapter 5: Multitasking Systems – an Introduction
- 5.1 The Task Model of Software
- 5.1.1 Modeling – What and Why
- 5.1.2 Modeling Executing Software – the Single-Task Structure
- 5.1.3 Multiple Tasks – Why?
- 5.1.4 Using Interrupts to Concurrent Task Operations
- 5.1.5 Introduction to the Operating System
- 5.2 Controlling Task Execution – Scheduling
- 5.2.1 Scheduling and Time Slicing Operations
- 5.2.2 Scheduling and Priority-Driven Operations
- 5.2.3 System Responsiveness and Mixed Scheduling Policies
- 5.3 Sharing Resources in Multitasking Systems
- 5.3.1 Problems with Sharing Resources
- 5.3.2 The Binary Semaphore
- 5.3.3 The General or Counting Semaphore
- 5.3.4 Semaphore Weaknesses
- 5.3.5 The Mutex
- 5.3.6 The Simple Monitor
- 5.4 Contention Problems in Multitasking Systems
- 5.4.1 Resource Contention and Deadlocks
- 5.4.2 The Priority Inversion Problem
- 5.4.3 The Priority Ceiling Protocol
- 5.5 Inter-task Communication
- 5.5.1 Introduction
- 5.5.2 Task Coordination and Synchronization without Data Transfer – General Aspects
- 5.5.3 Task Interaction without Data Transfer
- 5.5.4 Data Transfer without Task Synchronization or Coordination
- 5.5.5 Task Synchronization with Data Transfer
- 5.6 Review
- 5.7 Background Reading Material
- 5.1 The Task Model of Software
- Chapter 6: Diagramming – an Introduction
- 6.1 Diagrams – Why?
- 6.1.1 Introduction
- 6.1.2 Diagrams as a Design Tool
- 6.1.3 Diagrams for Design Documentation
- 6.1.4 Diagrams for Maintenance
- 6.1.5 Diagrams for Communication
- 6.2 The Essentials of Software Diagrams
- 6.2.1 Fundamentals
- 6.2.2 Basic Qualities
- 6.2.3 Real-Time Systems Diagramming – Matching Ends to Needs
- 6.2.4 Practical Diagramming Techniques – a General Comment
- 6.3 Review
- 6.4 Exercises
- 6.5 References and Further Reading
- 6.1 Diagrams – Why?
- Chapter 7: Practical Diagramming Methods
- 7.1 Introduction
- 7.2 Diagrams for Functionally Structured Methods
- 7.2.1 Context Diagrams
- 7.2.2 Entity-Relationship Diagrams (ERDs)
- 7.2.3 State Transition Diagrams and State Transition Tables
- 7.2.4 Functional and Data Flow Diagrams
- 7.2.5 Specifying Program Structures – Structure Charts, Flowcharts, and Program Description Languages
- 7.2.6 Message Sequence Diagrams
- 7.2.7 SDL (Specification and Description Language) Process Diagrams
- 7.2.8 Event-Response Lists
- 7.3 UML Diagrams for Object-Oriented Designs
- 7.3.1 Use Case Diagrams
- 7.3.2 Deployment Diagrams
- 7.3.3 Packages and Package Diagrams
- 7.3.4 Class Diagrams
- 7.3.5 Object and Object Communication Diagrams
- 7.3.6 Wiring Objects Together – Ports and Interfaces
- 7.3.7 Statecharts
- 7.3.8 Sequence Diagrams
- 7.3.9 Activity Diagrams
- 7.3.10 Components and Component Diagrams
- 7.3.11 Artifacts
- 7.4 Extensions, Variations, and Project-Specific Diagrams
- 7.5 Diagrams and the Design Process
- 7.6 Review
- 7.7 Exercises
- 7.8 References and Further Reading
- Chapter 8: Designing and Constructing Software – Code-Related Issues
- 8.1 Fundamental Design and Construction Methods
- 8.1.1 Introduction
- 8.1.2 An Evaluation of Design and Construction Methods
- 8.2 Code Development and Packaging
- 8.2.1 Code Development and the Physical Software Model
- 8.2.2 Software Construction Methods – General
- 8.2.3 Introduction to Component Technology
- 8.2.4 Code Packaging and Components
- 8.2.5 Classes, Packages, and Artifacts
- 8.3 Important Features of Programming Languages
- 8.3.1 Introduction
- 8.3.2 Choosing a Programming Language – the Real Questions
- 8.3.3 High-Level Languages – General Requirements
- 8.3.4 Modularity, Encapsulation, and Information Hiding
- 8.3.5 Program Syntax and Layout Rules – the Readability Factor
- 8.3.6 Variable Usage – Scope, Visibility, Lifetime, and Declaration.
- 8.3.7 Data Types – Concepts and Uses
- 8.3.8 Program Flow Control
- 8.3.9 Interfacing to Other Languages
- 8.3.10 Exception Handling
- 8.3.11 Accessing Processor Hardware – Low-Level Facilities
- 8.3.12 Assembly Language Programming
- 8.3.13 Miscellaneous Items
- 8.4 Choosing a High-Level Language for Embedded Systems
- 8.4.1 Basic Requirements
- 8.4.2 Assessed Languages – Background
- 8.4.3 Assessed Languages – Comparison and Comment
- 8.4.4 Python and MicroPython
- 8.5 Review
- 8.6 Important and Useful Reading
- 8.1 Fundamental Design and Construction Methods
- Chapter 9: Software Analysis and Design – Methods and Methodologies
- 9.1 The Development Process
- 9.1.1 General Description
- 9.1.2 Methods, Methodologies, and Tools
- 9.2 Viewpoint Analysis for Deriving Requirements
- 9.2.1 Viewpoint Analysis and CORE
- 9.2.2 CORE Fundamentals
- 9.2.3 Detailed Aspects and Notation
- 9.2.4 Design Example – Steam Propulsion System
- 9.2.5 A Comment on Analysis Tools
- 9.3. Design Implementation Using Functionally Structured Techniques
- 9.3.1 Overview of the Design Process
- 9.3.2 Developing the Ideal Model
- 9.3.3 Developing the Practical Model
- 9.4 Object-Oriented Analysis and Design
- 9.4.1 Design Example – Dipmeter Wireline Logging Tool
- 9.4.2 A Practical OOAD Development Process
- 9.4.3 Defining System Usage
- 9.4.4 Developing the Subsystem Structures
- 9.4.5 Developing the Ideal Model Object Structures
- 9.4.6 Developing the Specification Model Object Structures
- 9.4.7 Developing the Individual Processor Object Models
- 9.4.8 Developing the Multitasking Model
- 9.4.9 Developing Individual Tasks
- 9.4.10 Packaging the Software
- 9.5 Model-Driven Architecture
- 9.5.1 Fundamental Concepts
- 9.5.2 The PIM in Detail
- 9.5.3 Example Structural Model – from PIM to PSM to Code
- 9.5.4 Closing Comments
- 9.6 Model-Based Design (MBD)
- 9.6.1 MBD versus MDA
- 9.6.2 MBD – an Overview
- 9.6.3 Applying the MBD Process – a Brief Outline
- 9.7 Agile Software Development
- 9.7.1 Introduction and Basic Concepts
- 9.7.2 Agile Methods for Embedded Applications – the Interface Issue
- 9.7.3 The Issue of Project Development Methods – Agile versus Embedded
- 9.7.4 Practical Incremental Development Methods for Embedded Systems
- 9.8 Review
- 9.9 Further Useful Reading
- 9.1 The Development Process
- Chapter 10: Analyzing and Testing Source Code
- 10.1 Introduction
- 10.1.1 General Concepts
- 10.1.2 Software Evaluation Issues
- 10.1.3 Software Testing – the Broader Issues
- 10.2 Static Analysis
- 10.2.1 Introduction
- 10.2.2 Manual Static Analysis Methods
- 10.2.3 Automated Static Analysis Methods
- 10.3 Source Code Metrics – Code Size, Content, and Complexity
- 10.3.1 General
- 10.3.2 Halstead Software Metrics
- 10.3.3 The McCabe Cyclomatic Complexity Metric
- 10.4 Dynamic Analysis – Testing and Coverage Analysis
- 10.4.1 Overview of Dynamic Testing
- 10.4.2 Dynamic Testing in a Manual Environment
- 10.4.3 Dynamic Testing in an Automated Environment
- 10.4.4. Coverage Analysis
- 10.4.5. Practical Automated Dynamic Analysis
- 10.5 Integration Testing
- 10.5.1 Fundamentals
- 10.5.2 Integration and Test Strategies (1) – Combined Module and Integration Testing
- 10.5.3 Integration and Test Strategies (2) – Integration Testing Based on Unit Calls
- 10.5.4 Integration Complexity
- 10.6 Metrics for OO Designs
- 10.6.1 General Aspects
- 10.6.2 Inheritance, Polymorphism, and Testing Issues
- 10.7 Review
- 10.8 Further Reading
- 10.1 Introduction
- Chapter 11: Development Tools
- 11.1 An Outline of the Modern Development Process for Embedded Systems
- 11.2 The Software Development Process for Embedded Systems
- 11.2.1 The Software Production Cycle
- 11.2.2 Programming the Target Microcontroller
- 11.2.3 Simplifying the Process – Processor Configuration Tools
- 11.2.4 Finding and Fixing Software Problems
- 11.2.5 The Basics of Efficient Development Processes
- 11.3 Software Debugging – What and Why?
- 11.3.1 Debugging – Fundamental Concepts
- 11.3.2 Debugger – Basic Requirements and Operation
- 11.3.3 Development and Debugging Environments
- 11.4 Software Debugging on the Host
- 11.4.1 Host System Debugging – a Broad Overview
- 11.4.2 The Pros and Cons of Host System Debugging
- 11.5 Software Debugging on the Target – Software-Based Techniques
- 11.5.1 General
- 11.5.2 A Simple Monitor Program
- 11.5.3 In-Target Source-Level Debugging
- 11.5.4 The Last Comment
- 11.6 Software Debugging in the Target – Hardware-Based Methods
- 11.6.1 Introduction
- 11.6.2 A Basic Test Tool – the Bus Monitor
- 11.6.3 The Logic Analyzer
- 11.6.4 The In-Circuit Emulator
- 11.7 Software Debugging in The Target – Combined Hardware/Software Techniques
- 11.7.1 Host/Target Interactive Debugging – Software Tracing
- 11.7.2 On-Chip Debugging Methods – Overview
- 11.7.3 Simple Static On-Chip Debugging Methods
- 11.7.4 Dynamic OCD Schemes
- 11.8 Debugging in Host-As-Target Combinations
- 11.8.1 Background
- 11.8.2 PC-Based Targets – The Embedded PC
- 11.8.3 A PC as a Target
- 11.9 Testing Multitasking Software
- 11.9.1 Basic Issues
- 11.9.2 Practical Tool Aspects
- 11.10 Installing Code on the Target – Non-Volatile Software (Firmware)
- 11.10.1 Overview
- 11.10.2 The PROM Programmer
- 11.10.3 EPROM Emulators
- 11.10.4 In-Circuit Programming
- 11.11 Integrated Development Toolsets
- 11.11.1 Backend Toolsets
- 11.11.2 Fully Integrated Real-Time Development Environments
- 11.12 Review
- Chapter 12: Mission-Critical and Safety-Critical Systems
- 12.1 Introduction
- 12.1.1 Overview of Critical Systems
- 12.1.2 How Critical is Critical?
- 12.1.3 Improving System Reliability and Availability – General Strategies
- 12.2 System Specification Aspects
- 12.2.1 The Specification Problem – Again
- 12.2.2 Why Mathematics?
- 12.2.3 Formal Methods – General Concepts
- 12.2.4 Formal Specification Languages
- 12.2.5 An Example Formal Specification Using VDM
- 12.3 Numerical Issues
- 12.3.1 Problems in Disguise
- 12.3.2 Making Measurements
- 12.3.3 Basic Number Representation and Arithmetic
- 12.3.4 The Limitations of Finite Number Systems – General Points
- 12.3.5 Infinite Numbers, Model Numbers, and Error Bounds
- 12.3.6 Problems in Floating-Point Working
- 12.3.7 Problems in Fixed-Point Working
- 12.3.8 Internal Representation and Binary Notation
- 12.4 Application Software Aspects
- 12.4.1 Basic Design and Programming Issues (or Doing It Right in the First Place)
- 12.4.2 Dealing with Runtime Problems
- 12.5 Real-World Interfacing
- 12.5.1 Background
- 12.5.2 Fault Types and Identification – Inputs
- 12.5.3 Fault Detection Methods – Inputs
- 12.5.4 Fault Handling – Outputs
- 12.6 Operating Systems Aspects
- 12.6.1 General
- 12.6.2 Protection Techniques
- 12.6.3 Tasking Models and Scheduling
- 12.6.4 Operating Systems and Critical Distributed Applications
- 12.7 Processor Problems
- 12.7.1 Overview
- 12.7.2 Power-On Aspects
- 12.7.3 Runtime Issues
- 12.8 Hardware-Based Fault Tolerance
- 12.8.1 General Aspects
- 12.8.2 Fault-Tolerant Structures
- 12.8.3 Matching Structures to Requirements
- 12.9 Review
- 12.10 References and Further Reading
- 12.11 Some Important Standards
- 12.1 Introduction
- Chapter 13: Performance Engineering
- 13.1 Why Performance Engineering Is Important
- 13.1.1 Time as a Design Driver
- 13.1.2 Ignore Performance at Your Peril – Reactive versus Proactive Techniques
- 13.2 Performance Engineering – Requirements, Targets, and Achievables
- 13.3 Top-Down (Requirements-Driven) Performance Modeling
- 13.3.1 Specifying Targets – the Project-Management Analogy
- 13.3.2 Performance Targets and Time Budgeting in Real-Time Systems
- 13.4 Bottom-Up (Results-Driven) Performance Modeling
- 13.5 Middle-Out (Risk-Driven) Performance Modeling
- 13.6 Some Practical Issues in Performance Engineering
- 13.6.1 A General Comment
- 13.6.2 Modeling and Simulation Options
- 13.7 Review
- 13.8 References and Further Reading
- 13.1 Why Performance Engineering Is Important
- Chapter 14: Documentation
- 14.1 Documentation – What and Why?
- 14.1.1 The Role of Documentation
- 14.1.2 Documentation – Its Structure
- 14.1.3 A Model for System Documentation
- 14.2 Software Life Cycle Documentation – Overview
- 14.3 System Functional Specifications
- 14.3.1 Overview
- 14.3.2 Block Diagram Description
- 14.3.3 Functional Diagram Description
- 14.3.4 Requirements Specification
- 14.4 Software System Specifications
- 14.5 Source Code Aspects
- 14.5.1 Source Code Documentation – a Philosophy
- 14.5.2 Source Code Documentation – Practice
- 14.5.3 Source Code Review Documentation
- 14.6 Configuration Management and Version Control
- 14.6.1 General Aspects
- 14.6.2 More on Source Code Version Control
- 14.7 Review
- 14.8 Further Information
- 14.1 Documentation – What and Why?
- Glossary of terms
- Index
Статистика использования
pdf/2346940.pdf
|
Количество обращений: 1
За последние 30 дней: 0 Подробная статистика |
epub/2346940.epub
|
Количество обращений: 0
За последние 30 дней: 0 Подробная статистика |