Software Engineering for Embedded Systems

Methods, Practical Techniques, and Applications

Robert Oshana

• Publisher: Newnes
• Year: 2013
• Print ISBN: 9780124159174
• eBook ISBN: 9780124159419
• Topic: Computer Science
• Subtopic: Software Development
• Index: Computer Science

This Expert Guide gives you the techniques and technologies in software engineering to optimally design and implement your embedded system. Written by experts with a solutions focus, this encyclopedic reference gives you an indispensable aid to tackling the day-to-day problems when using software engineering methods to develop your embedded systems. With this book you will learn: - The principles of good architecture for an embedded system - Design practices to help make your embedded project successful - Details on principles that are often a part of embedded systems, including digital signal processing, safety-critical principles, and development processes - Techniques for setting up a performance engineering strategy for your embedded system software - How to develop user interfaces for embedded systems - Strategies for testing and deploying your embedded system, and ensuring quality development processes - Practical techniques for optimizing embedded software for performance, memory, and power - Advanced guidelines for developing multicore software for embedded systems - How to develop embedded software for networking, storage, and automotive segments - How to manage the embedded development process Includes contributions from: Frank Schirrmeister, Shelly Gretlein, Bruce Douglass, Erich Styger, Gary Stringham, Jean Labrosse, Jim Trudeau, Mike Brogioli, Mark Pitchford, Catalin Dan Udma, Markus Levy, Pete Wilson, Whit Waldo, Inga Harris, Xinxin Yang, Srinivasa Addepalli, Andrew McKay, Mark Kraeling and Robert Oshana. - Road map of key problems/issues and references to their solution in the text - Review of core methods in the context of how to apply them - Examples demonstrating timeless implementation details - Short and to- the- point case studies show how key ideas can be implemented, the rationale for choices made, and design guidelines and trade-offs

Chapter 1

Software Engineering of Embedded and Real-Time Systems

Robert Oshana

An embedded system is a computer system designed for a specific function within a larger system, and often has one or more real-time computing constraints. It is embedded as part of a larger device which can include hardware and mechanical parts. This is in stark contrast to a general-purpose computer, which is designed to be flexible and meet a wide range of end-user needs. The methods, techniques, and tools for developing software systems that were successfully applied to general purpose computing are not as readily applicable to embedded computing. Software systems running on networks of mobile, embedded devices must exhibit properties that are not always required of more traditional systems such as near-optimal performance, robustness, distribution, dynamism, and mobility. This chapter will examine the key properties of software systems in the embedded, resource-constrained, mobile, and highly distributed world. The applicability of mainstream software engineering methods is assessed and techniques (e.g., software design, component-based development, software architecture, system integration and test) are also discussed in the context of this domain. This chapter will overview embedded and real-time systems.

Keywords

software engineering; embedded systems; real-time systems; hard real-time; challenges

Chapter Outline

• Software engineering 1
• Embedded systems 7
  • Embedded systems are reactive systems 9
• Real-time systems 12
  • Types of real-time systems – soft and hard 12
    • Differences between real-time and time-shared systems 14
  • Examples of hard real-time 15
    • Based on signal sample, time to perform actions before next sample arrives 15
    • Hard real-time systems 15
  • Real-time event characteristics 17
    • Real-time event categories 17
  • Efficient execution and the execution environment 17
    • Efficiency overview 17
    • Resource management 18
• Challenges in real-time system design 18
  • Response time 19
  • Recovering from failures 20
  • The embedded system software build process 21
• Distributed and multi-processor architectures 23
• Software for embedded systems 24
  • Super loop architecture 24
    • Power-save super loop 25
    • Window lift embedded design 26
• Hardware abstraction layers (HAL) for embedded systems 27
• Summary 30

Software engineering

Over the past ten years or so, the world of computing has moved from large, static, desk-top machines to small, mobile, and embedded devices. The methods, techniques, and tools for developing software systems that were successfully applied in the former scenario are not as readily applicable in the latter. Software systems running on networks of mobile, embedded devices must exhibit properties that are not always required of more traditional systems:

• • near-optimal performance
• • robustness
• • distribution
• • dynamism
• • mobility.

This book will examine the key properties of software systems in the embedded, resource-constrained, mobile, and highly distributed world. We will assess the applicability of mainstream software engineering methods and techniques (e.g., software design, component-based development, software architecture, system integration and test) to this domain.

One of the differences in software engineering for embedded systems is the additional knowledge the engineer has of electrical power and electronics; physical interfacing of digital and analog electronics with the computer; and software design for embedded systems and digital signal processors (DSP).

Over 95% of software systems are actually embedded. Consider the devices you use at home on a daily basis;

• • cell phone, iPod, microwave
• • satellite receiver, cable box
• • car engine control unit
• • DVD player.

So what do we mean by software engineering for embedded systems? Let’s look at this in the context of engineering in general. Engineering is defined as the application of scientific principles and methods to the construction of useful structures and machines. This includes disciplines such as:

• • mechanical engineering
• • civil engineering
• • chemical engineering
• • electrical engineering
• • nuclear engineering
• • aeronautical engineering.

Software engineering is a term that is 35 years old, originating at a NATO conference in Garmisch, Germany, October 7–11, 1968. Computer science is the scientific basis and many aspects have been made systematic in software engineering:

• • methods/methodologies/techniques
• • languages
• • tools
• • processes.

We will explore all of these in this book.

The basic tenets of software engineering include:

• • development of software systems whose size/complexity warrants team(s) of engineers (or as David Parnas puts it, “multi-person construction of multi-version software”);
• • scope, which we will focus on the study of software process, development principles, techniques, and notations;
• • goal, in our case the production of quality software, delivered on time, within budget, satisfying customers’ requirements and users’ needs.

With this come the ever-present difficulties of software engineering that still exist today:

• • there are relatively few guiding scientific principles;
• • there are few universally applicable methods;
• • software engineering is as much managerial/psychological/sociological as it is technological.

There difficulties exist because software engineering is a unique form of engineering:

• • software is malleable;
• • software construction is human-intensive;
• • software is intangible;
• • software problems are unprecedentedly complex;
• • software directly depends upon the hardware;
• • software solutions require unusual rigor;
• • software has discontinuous operational nature.

Software engineering is not the same as software programming. Software programming usually involves a single developer developing “toy” applications and involves a relatively short lifespan. With programming, there is a single or few stakeholders and the project is mostly one-of-a-kind systems built from scratch with minimal maintenance.

Software engineering on the other hand involves teams of developers with multiple roles building complex systems with an indefinite lifespan. There are numerous stakeholders, families of systems, a heavy emphasis on reuse to amortize costs and a maintenance phase that accounts for over 60% of overall development costs.

There are economic and management aspects of software engineering. Software production includes the development and maintenance (evolution) of the system. Maintenance costs are the majority of all development costs. Quicker development is not always preferable. In other words, higher up-front costs may defray downstream costs. Poorly designed and implemented software is a critical cost factor. In this book we will focus on software engineering of ...

Table of contents

• Cover image
• Title page
• Table of Contents
• Copyright
• Software Engineering for Embedded Systems: A Roadmap
• Foreword to Software Engineering for Embedded Systems
• Acknowledgments
• About the Editors
• About the Authors
• Chapter 1. Software Engineering of Embedded and Real-Time Systems
• Chapter 2. Embedded Systems Hardware/Software Co-Development
• Chapter 3. Software Modeling for Embedded Systems
• Chapter 4. Software Design Architecture and Patterns for Embedded Systems
• Chapter 5. Real-Time Building Blocks: Events and Triggers
• Chapter 6. Hardware’s Interface to Embedded Software
• Chapter 7. Embedded Software Programming and Implementation Guidelines
• Chapter 8. Embedded Operating Systems
• Chapter 9. Software Reuse By Design in Embedded Systems
• Chapter 10. Software Performance Engineering for Embedded Systems
• Chapter 11. Optimizing Embedded Software for Performance
• Chapter 12. Optimizing Embedded Software for Memory
• Chapter 13. Optimizing Embedded Software for Power
• Chapter 14. Human Factors and User Interface Design for Embedded Systems
• Chapter 15. Embedded Software Quality, Integration and Testing Techniques
• Chapter 16. Software Development Tools for Embedded Systems
• Chapter 17. Multicore Software Development for Embedded Systems: This Chapter draws on Material from the Multicore Programming Practices Guide (MPP) from the Multicore Association
• Chapter 18. Safety-Critical Software Development
• Chapter 19. Intellectual Property
• Chapter 20. Managing Embedded Software Development
• Chapter 21. Agile Development for Embedded Systems
• Chapter 22. Embedded Software for Automotive Applications
• Chapter 23. Programming for I/O and Storage
• Chapter 24. Embedded Software for Networking Applications
• Chapter 25. Linux for Embedded Systems
• Appendix 1. ‘C’ Syntax Coding Standard: Source Code Development
• Appendix 2. On the C++ Programming Language for Embedded Software, Systems, and Platforms
• Case Study 1. Software Performance Engineering
• Case Study 2. A User Interface: Police Command and Control System
• Case Study 3. Transitioning to Multicore
• Case Study 4. Software Engineering for Embedded Systems Quality and Metrics Program
• Index