book

Embedded Software

Name: Embedded Software
ISBN: 9780750685832

by Jean J. Labrosse, Jack Ganssle, Robert Oshana, Colin Walls, Keith E. Curtis, Jason Andrews, David J. Katz, Rick Gentile, Kamal Hyder, Bob Perrin

September 2007

Intermediate to advanced

792 pages

19h 23m

English

Newnes

Read now

Unlock full access

Copyright
Newnes Know It All Series
About the Authors
Introduction
I.1. Development ChallengesI.1.1. Multiple ProcessorsI.1.2. Limited MemoryI.1.3. User InterfaceI.2. Reusable SoftwareI.2.1. Software ComponentsI.3. Real-Time Operating SystemI.3.1. RTOS Selection FactorsI.3.2. RTOS StandardsI.4. File SystemI.5. Universal Serial Port (USB)I.6. GraphicsI.7. NetworkingI.8. IPv6I.8.1. Who Needs a Web Server?I.8.2. SNMPI.9. Conclusion
1. Basic Embedded Programming Concepts
1.1. Numbering SystemsExample 1.1Example 1.2Example 1.31.1.1. Binary NumbersExample 1.41.2. Signed Binary NumbersExample 1.51.2.1. Fixed-Point Binary NumbersExample 1.61.2.2. Floating-Point Binary Numbers1.2.3. Alternate Numbering Systems1.2.4. Binary-Coded Decimal1.2.5. ASCII1.2.6. Error Detection1.3. Data Structures1.3.1. Simple Data TypesDeclaration 1.1Code Snippet 1.1Declaration 1.2Declaration 1.3Declaration 1.4Declaration 1.5Code Snippet 1.21.3.2. Complex Data TypesDeclaration 1.6Definition 1.1Declaration 1.7Declaration 1.8Declaration 1.9Declaration 1.10Code Snippet 1.3Code Snippet 1.4Declaration 1.11Memory 1.11.4. Communications Protocols1.4.1. Simple Data Broadcast1.4.2. Event-Driven Single Transfer1.4.3. Event-Driven Multielement Transfers1.5. Mathematics1.5.1. Binary Addition and SubtractionExample 1.7Example 1.81.5.2. Binary MultiplicationExample 1.9Example 1.10Algorithm 1.11.5.3. Binary DivisionExample 1.11Example 1.12Algorithm 1.21.6. Numeric Comparison1.6.1. Conditional StatementsCode Snippet 1.5Code Snippet 1.6Code Snippet 1.7Code Snippet 1.8Code Snippet 1.9Code Snippet 1.10Code Snippet 1.11Code Snippet 1.121.6.2. LoopsCode Snippet 1.13Code Snippet 1.14Code Snippet 1.151.6.3. Other Flow Control Statements1.7. State MachinesCode Snippet 1.16Algorithm 1.31.7.1. Data-Indexed State MachinesCode Snippet 1.17Code Snippet 1.181.7.2. Execution-Indexed State MachinesCode Snippet 1.19Code Snippet 1.20Code Snippet 1.21Code Snippet 1.22Code Snippet 1.23Code Snippet 1.24Code Snippet 1.25Code Snippet 1.261.7.3. Hybrid State MachinesCode Snippet 1.271.8. Multitasking1.8.1. Four Basic Requirements of Multitasking1.8.1.1. Context Switching1.8.1.2. Communications1.8.1.3. Managing Priorities1.8.1.4. Timing Control1.8.1.5. Operating Systems1.8.1.6. State Machine Multitasking
2. Device Drivers
2.1. In This Chapter2.2. Example 1: Device Drivers for Interrupt-Handling2.2.1. Interrupt Priorities2.2.2. Context Switching2.2.3. Interrupt Device Driver Pseudo Code Examples2.2.3.1. Interrupt-Handling Startup (Initialization) MPC8602.2.3.2. Initializing CPM for Interrupts—4 Step Process2.2.3.3. Interrupt-Handling Shutdown on MPC8602.2.3.4. Interrupt-Handling Disable on MPC8602.2.3.5. Interrupt-Handling Enable on MPC8602.2.3.6. Interrupt-Handling Servicing on MPC8602.2.4. Interrupt-Handling and Performance2.3. Example 2: Memory Device Drivers2.3.1. Memory Management Device Driver Pseudo Code Examples2.3.1.1. Memory Subsystem Startup (Initialization) on MPC8601. Initializing the Memory Controller and Connected ROM/RAM2. Initializing the Internal Memory Map on the MPC8603. Initializing the MMU on the MPC8602.3.1.2. Memory Subsystem Disable on MPC8602.3.1.3. Memory Subsystem Enable on MPC8602.3.1.4. Memory Subsystem Writing/Erasing Flash2.4. Example 3: Onboard Bus Device Drivers2.4.1. Onboard Bus Device Driver Pseudo Code Examples2.4.1.1. I2C Bus Startup (Initialization) on the MPC8602.5. Board I/O Driver Examples2.5.1. Example 4: Initializing an Ethernet Driver2.5.1.1. Data Encapsulation [Ethernet Frame]2.5.1.2. Media Access Management2.5.1.3. CDMA/CD (MAC Sublayer) Transmission Mode2.5.1.4. CDMA/CD (MAC Sublayer) Reception Mode2.5.1.5. Motorola/Freescale MPC823 Ethernet Example2.5.1.6. MPC823 Ethernet Driver Pseudo Code2.5.1.7. NetSilicon NET+ARM40 Ethernet ExampleNET+ARM40 Pseudo Code2.5.2. Example 5: Initializing an RS-232 Driver2.5.2.1. Motorola/Freescale MPC823 RS-232 Example2.5.2.2. MPC823 Serial Driver Pseudo Code2.6. Summary
3. Embedded Operating Systems
3.1. In This Chapter3.2. What Is a Process?3.3. Multitasking and Process Management3.3.1. Process ImplementationExample 3.1: Creating a Task in vxWorksExample 3.2: Jbed RTOS and Task CreationExample 3.3: Embedded Linux and fork/execExample 3.4: vxWorks Wind Kernel and StatesExample 3.5: Jbed Kernel and StatesExample 3.6: Embedded Linux and States3.3.2. Process Scheduling3.3.2.1. Preemptive Scheduling and the Real-Time Operating System (RTOS)Example 3.7: vxWorks SchedulingExample 3.8: Jbed and EDF SchedulingExample 3.9: TimeSys Embedded Linux Priority-based Scheduling3.3.3. Intertask Communication and SynchronizationExample 3.10: vxWorks SemaphoresExample 3.11: Message Passing in vxWorks3.3.3.1. Signals and Interrupt Handling (Management) at the Kernel LevelExample 3.12: Interrupt Handling in vxWorks3.4. Memory Management3.4.1. User Memory Space3.4.1.1. SegmentationExample 3.13: vxWorks Memory Management and SegmentationExample 3.14: Jbed Memory Management and SegmentationExample 3.15: Linux Memory Management and Segmentation3.4.1.2. Paging and Virtual Memory3.4.1.3. Virtual Memory3.4.2. Kernel Memory Space3.5. I/O and File System Management3.6. OS Standards Example: POSIX (Portable Operating System Interface)Example 3.16: Linux POSIX ExampleExample 3.17: vxWorks POSIX Example3.7. OS Performance Guidelines3.8. OSes and Board Support Packages (BSPs)3.8.1. Advantages and Disadvantages of Real-Time Kernels3.9. Summary
4. Networking
4.1. Introduction to the RCM3200 Rabbit Core4.2. Introduction to the Dynamic C Development Environment4.2.1. Development4.2.2. Debugging4.3. Brief Introduction to Dynamic C Libraries4.4. Memory Spaces in Dynamic C4.4.1. Rabbit’s Memory Segments4.4.2. Dynamic C’s Memory Usage without Separate I & D Space4.4.3. Placing Functions in XMEM4.4.4. Separate Instruction and Data Memory4.4.5. Putting It All Together4.5. How Code Is Compiled and Run4.5.1. How Code Is Built in Traditional Development Environments4.5.2. How Code Is Built with Dynamic C4.6. Setting Up a PC as an RCM3200 Development System4.7. Time to Start Writing Code!4.7.1. Project: Everyone’s First Rabbit Program4.7.2. Dynamic C’s Debugging Features4.7.3. Dynamic C Help4.7.4. Single Stepping4.7.5. Adding a Breakpoint4.7.6. Watch Expressions4.7.7. Dynamic C Is Not ANSI C4.7.8. Dynamic C Memory Spaces4.8. Embedded Networks4.9. Dynamic C Support for Networking Protocols4.9.1. Common Networking Protocols4.9.2. Optional Modules Available for Dynamic C4.10. Typical Network Setup4.10.1. Typical Corporate Network4.10.2. Typical Home Network4.11. Setting Up a Core Module’s Network Configuration4.11.1. Setting Up the IP Address4.11.2. Link Layer Selection4.11.3. TCP/IP Definitions at Compile Time4.11.4. TCP/IP Definitions at Runtime4.11.5. Debugging Macros for Networking4.12. Project 1: Bringing Up a Rabbit Core Module for Networking4.12.1. Configuration for Static Addressing4.12.2. Configuration for Dynamic Addressing4.12.3. A Special Case for Dynamic Addressing4.13. The Client Server Paradigm4.13.1. What to Be Careful about in Client Server Programming4.14. The Berkeley Sockets Interface4.14.1. Making a Socket Connection4.15. Using TCP versus UDP in an Embedded Application4.16. Important Dynamic C Library Functions for Socket Programming4.16.1. Functions Used for Connection Initialization or Termination4.16.2. Functions Used to Determine Socket Status4.16.3. Functions Used to Send or Receive Data4.16.4. Blocking versus Nonblocking Functions4.17. Project 2: Implementing a Rabbit TCP/IP Server4.17.1. The Server TCP/IP State Machine4.17.2. Working with General-Purpose TCP Utilities4.17.3. Working with a Java TCP/IP Client4.17.4. Working with a C++ TCP/IP Client4.18. Project 3: Implementing a Rabbit TCP/IP Client4.18.1. Disabling the Windows XP Firewall4.18.2. Verifying the Client Code4.18.3. Working with a Java TCP/IP Server4.18.4. Working with a TCP/IP Server in C#4.19. Project 4: Implementing a Rabbit UDP Server4.19.1. Working with a Java UDP Client4.19.2. Working with a C++ UDP Client4.20. Some Useful (and Free!) Networking Utilities4.20.1. Ping4.20.2. Traceroute4.20.3. Ethereal4.20.4. Netcat4.20.5. Online Tools4.21. Final Thought
5. Error Handling and Debugging
5.1. The Zen of Embedded Systems Development and Troubleshooting5.1.1. The DEVELOPER Hat5.1.2. Regression Testing—Test Early and Test Often5.1.3. Case Study—Big Bang Integration and No Regression Test Suite5.1.4. The FINDER Hat5.1.5. The FIXER Hat5.2. Avoid Debugging Altogether—Code Smart5.2.1. Guideline #1: Use Small Functions5.2.2. Guideline #2: Use Pointers with Great Care5.2.3. Guideline #3: Comment Code Well5.2.4. Guideline #4: Avoid “Magic Numbers”5.3. Proactive Debugging5.4. Stacks and Heaps5.5. Seeding Memory5.6. Wandering Code5.7. Special Decoders5.8. MMUs5.9. Conclusion5.10. Implementing Downloadable Firmware with Flash Memory5.11. The Microprogrammer5.12. Advantages of Microprogrammers5.13. Disadvantages of Microprogrammers5.14. Receiving a Microprogrammer5.15. A Basic Microprogrammer5.16. Common Problems and Their Solutions5.16.1. Debugger Doesn’t Like Writeable Code Space5.16.2. Debugger Doesn’t Like Self-relocating Code5.16.3. Can’t Generate Position-independent Code5.16.4. No Firmware at Boot Time5.16.5. Persistent Watchdog Time-out5.16.6. Unexpected Power Interruption5.17. Hardware Alternatives5.17.1. Separating Code and Data5.17.2. Flexible and Safe5.18. Memory Diagnostics5.19. ROM Tests5.20. RAM Tests5.21. Nonvolatile Memory5.22. Supervisory Circuits5.23. Multibyte Writes5.24. Testing5.25. Conclusion5.26. Building a Great Watchdog5.27. Internal WDTs5.28. External WDTs5.29. Characteristics of Great WDTs5.30. Using an Internal WDT5.31. An External WDT5.32. WDTs for Multitasking5.33. Summary and Other Thoughts
6. Hardware/Software Co-Verification
6.1. Embedded System Design Process6.1.1. Requirements6.1.2. System Architecture6.1.3. Microprocessor Selection6.1.4. Hardware Design6.1.5. Software Design6.1.6. Hardware and Software Integration6.2. Verification and Validation6.2.1. Verification: Does It Work?6.2.2. Validation: Did We Build the Right Thing?6.3. Human Interaction6.4. Co-Verification6.4.1. History of Hardware/Software Co-Verification6.4.1.1. Commercial Co-Verification Tools Appear6.4.2. Co-Verification Defined6.4.2.1. Definition6.4.2.2. Benefits of Co-Verification6.4.2.3. Project Schedule Savings6.4.2.4. Co-Verification Enables Learning by Providing Visibility6.4.2.5. Co-Verification Improves Communication6.4.2.6. Co-Verification versus Co-Simulation6.4.2.7. Co-Verification versus Codesign6.4.2.8. Is Co-Verification Really Necessary?6.4.3. Co-Verification Methods6.4.3.1. Native Compiling Software6.4.3.2. Instruction Set Simulation6.4.3.3. Hardware Stubs6.4.3.4. Real-Time Operating System (RTOS) Simulator6.4.3.5. Microprocessor Evaluation Board6.4.3.6. Waveforms, Log Files, and Disassembly6.4.4. A Sample of Co-Verification Methods6.4.4.1. Host-Code Mode with Logic Simulation6.4.4.2. Instruction Set Simulation with Logic Simulation6.4.4.3. C Simulation6.4.4.4. RTL Model of CPU with Software Debugging6.4.4.5. Hardware Model with Logic Simulation6.4.4.6. Evaluation Board with Logic Simulation6.4.4.7. In-Circuit Emulation6.4.4.8. FPGA Prototype6.4.5. Co-Verification Metrics6.4.5.1. Performance6.4.5.2. Verification Accuracy6.4.5.3. AHB Arbitration and Cycle Accuracy Issues6.4.5.4. Modeling Summary6.4.5.5. Synchronization6.4.5.6. Types of Software6.4.5.7. Other Metrics

7. Techniques for Embedded Media Processing
7.1. A Simplified Look at a Media Processing System7.1.1. Core Processing7.1.2. Input/Output Subsystems—Peripheral Interfaces7.1.2.1. Subsystem Control—Low-Speed Serial Interfaces7.1.2.2. Storage7.1.2.3. Connectivity7.1.2.4. Data Movement7.1.3. Memory Subsystem7.2. System Resource Partitioning and Code Optimization7.3. Event Generation and Handling7.3.1. System Interrupts7.4. Programming Methodology7.5. Architectural Features for Efficient Programming7.5.1. Multiple Operations per Cycle7.5.2. Hardware Loop Constructs7.5.3. Specialized Addressing Modes7.5.3.1. Byte Addressability7.5.3.2. Circular Buffering7.5.3.3. Bit Reversal7.5.4. Interlocked Instruction Pipelines7.6. Compiler Considerations for Efficient Programming7.6.1. Choosing Data Types7.6.1.1. Arrays versus Pointers7.6.1.2. Division7.6.1.3. Loops7.6.1.4. Data Buffers7.6.1.5. Intrinsics and In-lining7.6.1.6. Volatile Data7.7. System and Core Synchronization7.7.1. Load/Store Synchronization7.7.2. Ordering7.7.3. Atomic Operations7.8. Memory Architecture—the Need for Management7.8.1. Memory Access Trade-offs7.8.2. Instruction Memory Management—to Cache or to DMA?7.8.3. Data Memory Management7.8.3.1. What about Data Cache?7.8.4. System Guidelines for Choosing between DMA and Cache7.8.4.1. Instruction Cache, Data DMA7.8.4.2. Instruction Cache, Data DMA/Cache7.8.4.3. Instruction DMA, Data DMA7.8.5. Memory Management Unit (MMU)7.8.5.1. CPLB Management7.8.5.2. Memory Translation7.9. Physics of Data Movement7.9.1. Grouping Like Transfers to Minimize Memory Bus Turnarounds7.9.2. Understanding Core and DMA SDRAM Accesses7.9.3. Keeping SDRAM Rows Open and Performing Multiple Passes on Data7.9.4. Optimizing the System Clock Settings and Ensuring Refresh Rates Are Tuned for the Speed at Which SDRAM Runs7.9.5. Exploiting Priority and Arbitration Schemes between System Resources7.10. Media Processing Frameworks7.10.1. What Is a Framework?7.11. Defining Your Framework7.11.1. The Application Timeline7.11.1.1. Evaluating BandwidthProcessor BandwidthDMA BandwidthMemory Bandwidth7.12. Asymmetric and Symmetric Dual-Core Processors7.13. Programming Models7.13.1. Asymmetric Programming Model7.13.2. Homogeneous Programming Model7.13.2.1. Master-Slave Programming Model7.13.2.2. Pipelined Programming Model7.14. Strategies for Architecting a Framework7.14.1. Processing Data On-the-Fly7.14.2. Programming Ease Trumps Performance7.14.3. Performance-based Framework7.14.3.1. Image Pipe and Compression Example7.14.3.2. High Performance Decoder Example7.14.4. Framework Tips7.15. Other Topics in Media Frameworks7.15.1. Audio-Video Synchronization7.15.2. Managing System Flow7.15.3. Frameworks and Algorithm Complexity
8. DSP in Embedded Systems
8.1. Overview of Embedded Systems and Real-Time Systems8.2. Real-Time Systems8.2.1. Types of Real-Time Systems—Soft and Hard8.3. Hard Real-Time and Soft Real-Time Systems8.3.1. Introduction8.3.2. Differences between Real-Time and Time-Shared Systems8.3.3. DSP Systems Are Hard Real-Time8.3.3.1. Based on Signal Sample, Time to Perform Actions Before Next Sample Arrives8.3.3.2. Hard Real-Time Systems8.3.4. Real-Time Event Characteristics—Real-Time Event Categories8.4. Efficient Execution and the Execution Environment8.4.1. Efficiency Overview8.4.2. Resource Management8.5. Challenges in Real-Time System Design8.5.1. Response Time8.5.2. Recovering from Failures8.5.3. Distributed and Multiprocessor Architectures8.5.4. Embedded Systems8.5.4.1. Embedded Systems Are Reactive Systems8.6. Summary8.7. Overview of Embedded Systems Development Life Cycle Using DSP8.8. The Embedded System Life Cycle Using DSP8.8.1. Step 1—Examine the Overall Needs of the System8.8.1.1. What Is a DSP Solution?8.8.2. Step 2—Select the Hardware Components Required for the System8.8.3. Hardware Gates8.8.4. Software-Programmable8.8.5. General-Purpose Processors8.8.6. Microcontrollers8.8.7. FPGA Solutions8.8.8. Digital Signal Processors8.8.9. A General Signal Processing Solution8.8.10. DSP Acceleration Decisions8.8.11. Step 3—Understand DSP Basics and Architecture8.8.12. Models of DSP Processing8.8.13. Input/Output Options8.8.14. Calculating DSP Performance8.8.15. DSP Software8.8.16. DSP Frameworks8.9. Optimizing DSP Software8.10. What Is Optimization?8.11. The Process8.12. Make the Common Case Fast8.13. Make the Common Case Fast—DSP Architectures8.14. Make the Common Case Fast—DSP Algorithms8.15. Make the Common Case Fast—DSP Compilers8.16. An In-Depth Discussion of DSP Optimization8.17. Direct Memory Access8.18. Using DMA8.18.1. Staging Data8.18.1.1. An Example8.18.2. Pending versus Polling8.18.3. Managing Internal Memory8.19. Loop Unrolling8.19.1. Filling the Execution Units8.19.2. Reducing Loop Overhead8.19.3. Fitting the Loop to Register Space8.19.4. Trade-offs8.20. Software Pipelining8.20.1. An Example8.20.1.1. A Serial Implementation8.20.1.2. A Minimally Parallel Implementation8.20.1.3. Compiler-Generated Pipeline8.20.1.4. An Implementation with Restrict Keyword8.20.2. Enabling Software Pipelining8.20.3. Interrupts and Pipelined Code8.21. More on DSP Compilers and Optimization8.21.1. Compiler Architecture and Flow8.21.2. Compiler Optimizations8.21.2.1. Instruction Selection8.21.2.2. Latency and Instruction Scheduling8.21.2.3. Register Allocation8.21.3. Compile Time Options8.21.3.1. Understanding What the Compiler Is Thinking8.22. Programmer Helping Out the Compiler8.22.1. Pragmas8.22.2. Intrinsics8.22.3. Keywords8.22.4. Inlining8.22.5. Reducing Stack Access Time8.22.6. Compilers Helping Out the Programmer8.22.7. Summary of Coding Guidelines8.23. Profile-Based Compilation8.23.1. Advantages8.23.2. Issues with Debugging Optimized Code8.23.3. Summary of the Code Optimization Process8.23.4. Summary8.24. References
9. Practical Embedded Coding Techniques
9.1. Reentrancy9.2. Atomic Variables9.3. Two More Rules9.4. Keeping Code Reentrant9.5. Recursion9.6. Asynchronous Hardware/Firmware9.7. Race Conditions9.8. Options9.9. Other RTOSes9.10. Metastable States9.11. Firmware, Not Hardware9.12. Interrupt Latency9.13. Taking Data9.14. Understanding Your C Compiler: How to Minimize Code Size9.15. Modern C Compilers9.15.1. The Structure of a Compiler9.15.2. The Meaning of a Program9.15.3. Basic Transformations9.15.4. Register Allocation9.15.5. Function Calls9.15.6. Function Inlining9.15.7. Low-Level Code Compression9.15.8. Linker9.15.9. Controlling Compiler Optimization9.15.10. Memory Model9.16. Tips on Programming9.16.1. Use the Right Data Size9.16.2. Use the Best Pointer Types9.16.3. Structures and Padding9.16.4. Use Function Prototypes9.16.5. Use Parameters9.16.6. Do Not Take Addresses9.16.7. Do Not Use Inline Assembly Language9.16.8. Do Not Write Clever Code9.16.9. Use Switch for Jump Tables9.16.10. Investigate Bit Fields Before Using Them9.16.11. Watch Out for Library Functions9.16.12. Use Extra Hints9.17. Final Notes9.18. Acknowledgments
10. Development Technologies and Trends
10.1. How to Choose a CPU for Your System on Chip Design10.1.1. Design Complexity10.1.2. Design Reuse10.1.3. Memory Architecture and Protection10.1.4. CPU Performance10.1.5. Power Consumption10.1.6. Costs10.1.7. Software Issues10.1.8. Multicore SoCs10.1.9. Conclusions10.2. Emerging Technology for Embedded Systems Software Development10.2.1. Microprocessor Device Technology10.2.2. System Architecture10.2.3. Design Composition10.2.4. Software Content10.2.5. Programming Languages10.2.6. Software Team Size and Distribution10.2.7. UML and Modeling10.2.8. Key Technologies10.2.9. Conclusions10.3. Making Development Tool Choices10.3.1. The Development Tool Chain10.3.2. Compiler Features10.3.3. Extensions for Embedded Systems10.3.3.1. Impact of Real-Time Systems10.3.4. Optimizations10.3.5. Build Tools: Key Issues Recapped10.3.6. Debugging10.3.6.1. Debugger Features10.3.6.2. Development Phases10.3.6.3. Native Debugger10.3.6.4. Debugger with Simulator10.3.6.5. Debugger with ICE Interface10.3.6.6. Debugger with Monitor10.3.6.7. Debugger with Hardware Assist10.3.6.8. Debugger with RTOS10.3.7. Debug Tools: Key Issues Recapped10.3.8. Standards and Development Tool Integration10.3.9. Implications of Selections10.3.9.1. Target Chips10.3.9.2. Host Computers10.3.9.3. RTOS10.3.10. Conclusions10.4. Eclipse—Bringing Embedded Tools Together10.4.1. Eclipse Platform Philosophy10.4.2. Platform10.4.3. How Eclipse Gets Embedded10.4.4. Conclusions10.5. Embedded Software and UML10.5.1. Why Model in UML?10.5.2. Separating Application from Architecture10.5.2.1. Blueprint Development10.5.2.2. What’s Wrong with That?10.5.2.3. Model Compilers10.5.2.4. Sets, States, and Functions10.5.2.5. Rules10.5.2.6. Open Translation10.5.3. xtUML Code Generation10.5.4. Conclusions10.6. Model-based Systems Development with xtUML10.6.1. Why Is Building an Embedded System so Difficult?10.6.1.1. Every Project Has at Least Two Fundamental ChallengesIntegration: Where the Fun Begins10.6.1.2. So What’s a Few Interface Problems Among Friends?10.6.1.3. The Suboptimal Partition10.6.1.4. The State of the Practice10.6.2. A Better Solution10.6.2.1. Interface Problems?10.6.2.2. What about the Partition?10.6.3. Experience to Date10.7. The Future

Content preview from Embedded Software

Chapter 6. Hardware/Software Co-Verification

Jason Andrews

Embedded System Design Process

The process of embedded system design generally starts with a set of requirements for what the product must do and ends with a working product that meets all of the requirements. Following is a list of the steps in the process and a short summary of what happens at each state of the design. The steps are shown in Figure 6.1.

Figure 6.1. Embedded System Design Process

Requirements

The requirements and product specification phase documents and defines the required features and functionality of the product. Marketing, sales, engineering, or any other individuals who ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Software Engineering for Embedded Systems

Publisher Resources

ISBN: 9780750685832

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design