CELEBRATE EARTH WEEK
Save 70% on video training and simulators now through April 27*—use code EARTH. Shop now.
The OCTOPUS method provides a systematic approach for developing object-oriented software for embedded real-time systems. This book describes the well-integrated OCTOPUS development process that covers the major phases of developing software. From requirements specifications to implementation, the models are continuously and clearly linked. KEY TOPICS: Covers concurrency, synchronization, communication, the handling of interrupts, ASICs, hardware interfaces, and end-to-end response time through the system. MARKET: For object-oriented software developers, programmers, and embedded-system engineers.
Real-time Systems. Object-Oriented Methods. Concurrency in a Real- time System. Object-Oriented Concurrency Models. Levels of Concurrency. Design Criteria of OCTOPUS. Introduction to Case Studies.
Roadmap and Structuring the Development Process. System Requirements Phase. System Architecture Phase. Subsystem Analysis Phase. Subsystem Design Phase. Subsystem Implementation Phase.
Use Cases. Use Case Diagram. System Context Diagram.
Modular Structure. Early Division into Subsystems. Subsystems Diagram. Incremental Development. Interfaces. Example.
Object Model. Functional Model. Dynamic Model. Analysis of the Hardware Wrapper. Summary.
Design Objects. Interaction of Objects. Class Outlines. Design of Concurrency. Outlines of Processes and Messages. Design of the Hardware Wrapper. Summary.
Basic Concepts. Deriving Process Priorities. Timing and Concurrency Behavior.
C++ and C Interpretability. Member Access Control. Visibility. Memory and Performance Optimization. Synchronization. Implementing Statecharts. Constructing Global Objects. Development Environment.
System Requirements Specification. SLT Application Subsystem Analysis. SLT Application Subsystem Design. Exercise: Hardware Wrapper.
Recapped System Requirements Specification. Application Subsystem Analysis. Analysis and Design of the Hardware Wrapper. Design of Application Subsystem.
Notation Summary. Case Tools. OCTOPUS Roadmap.
This book is a practical guide for engineers and managers of software development projects, particularly for embedded real-time systems. It offers two case studies that demonstrate how to master the complexity of these systems. The book is most useful for readers interested in the crossover of object-oriented technology and real-time systems. Anybody seeking knowledge in the two areas will also find it worthwhile.
It can be used in undergraduate and graduate courses on real-time systems and object-oriented software development.
Basic knowledge about object-oriented concepts and C++ is useful, but not essential. It also helps if the reader has some background in real-time systems. Otherwise the book is self-contained.
Embedded software has a special characteristic which distinguishes it from other branches of software: it is tightly connected to its physical environment through sensors and actuators. Normally, it is real-time software because it has to react to many events within specified time limits.
Object-oriented technology helps in the development of embedded real-time systems in a way that naturally maps to the inherent nature of the systems being built, while providing benefits such as reuse, increased extendibility, and robustness, already well-known in the development of other branches of software.
The OCTOPUS Method
Because of the diverse needs of different application domains, an efficient method for software development has to be domain specific, focusing on the important aspects of its intended application domain. OCTOPUS provides a systematic approach for developing object-oriented software for embedded real-time systems. It provides solutions to many important problems such as: concurrency, synchronization, communication, interrupt handling, ASICs, hardware interfaces and end-to-end response time through the system.
OCTOPUS has a well-integrated development process covering the major phases of software development. From requirements specification to implementation, the models are continuously and clearly linked. Incremental development of the software system is supported.
OCTOPUS approach also supports the development of heterogeneous systems where the object-oriented solution is a part of a non-object-oriented system. A conventional real-time operating system is used as an implementation platform. The dilemma of merging processes with objects is solved by a systematic and efficient procedure that maps objects into processes.
The OCTOPUS method adopts, as far as possible, the notations of the well-known OMT method, and applies standards. OCTOPUS introduces additional notations only when required by the special constraints of embedded real-time systems.
OCTOPUS is the marriage of object-oriented techniques with real-time systems. It bridges the gap between them. It can help real-time system designers to model, design, and implement their system faster. The resulting system is robust and reliable.
Chapter 1 is an introduction to real-time systems and concurrency models, and includes a comparison to other object-oriented approaches as well as an introduction to the case studies. The OCTOPUS method in a nutshell is the subject of Chapter 2, whereas Chapters 3 deals with the requirements specification, how to apply use cases to capture requirements and how to build a system context model. Chapter 4 deals with the system decomposition: how to divide a large system into a number of manageable subsystems, how to define the interfaces between them and how to develop them incrementally.
Analysis and design of a subsystem is described in Chapters 5 and 6, respectively. The analysis chapter emphasizes the dynamic model and the linkage to the object model. The design chapter provides a clear transformation of the analysis results to a description of the solution. It explains the mapping between objects and processes and the design of the hardware wrapper.
Chapter 7 discusses issues which affect the configuration of the software system such as priorities of processes and the verification of the timing requirements. Chapter 8 treats detailed design issues and implementation aspects that are specific to embedded real-time systems when using the C++ programming language.
Application of the OCTOPUS method is practically demonstrated in two case studies in Chapters 9 and 10: the first is based on a real telecommunication product and the second is the popular Cruise Control system. The latter can be used to compare OCTOPUS to different methods. The reference manual of this book, Chapter 11, includes a notation summary and OCTOPUS roadmap.
This book can be used in different ways. An efficient way may be to read the whole book from start to finish first and after that, depending on the phase of the project, to use it as a guide on theory, process and application of the OCTOPUS method. After some time, when the reader is familiar with the method, the case studies and the reference manual of this book are the chapters, he or she will refer to frequently retrieving some detail.
We are very grateful to our employer, Nokia Corporation. Nokia has always achieved its greatest success by innovative application of new technologies in its products. This gave us the opportunity to develop the approach presented in this book and to introduce it successfully in real applications. We are also very grateful to our colleagues in the Software Technology Laboratory at Nokia Research Center for their confidence, continuous support and constructive criticism.
Projects applying the OCTOPUS method were carried out at Nokia Telecommunications and Nokia Mobile Phones. Other projects are still ongoing, and new ones are being planned. We wish to thank all members of those projects for their valuable feedback.
We wish to thank Pertti Lounamaa, head of the laboratory, who has made this book possible by giving us the opportunity and the facilities to develop and experiment the ideas presented here.
Many individuals helped in the review of the manuscript, but in particular we wish to thank Jorma Kuha and Laszlo Huray. Their ideas and comments are much appreciated. Jorma Kuha helped also a great deal by thoroughly checking all the C++ listings for syntactical and semantical errors. He also helped us in developing macros which facilitated the writing of the book.
We used a case tool called KISS, which is developed at Nokia Research Center. Our thanks to Antero Taivalsaari and to the developers of KISS.
We also would like to thank Mohammed Fayad for triggering us to write this book at a workshop in OOPSLA'94 conference.
Finally and most importantly we wish to thank our families for their patience and encouragement during the many long weekends and evenings that went into the writing of this book.