The Firmware Handbook

Opis

The Firmware Handbook provides a comprehensive reference for firmware developers looking to increase their skills and productivity. It addresses each critical step of the development process in detail, including how to optimize hardware design for better firmware. Topics covered include real-time issues, interrupts and ISRs, memory management (including Flash memory), handling both digital and analog peripherals, communications interfacing, math subroutines, error handling, design tools, and troubleshooting and debugging.

This book is not for the beginner, but rather is an in-depth, comprehensive one-volume reference that addresses all the major issues in firmware design and development, including the pertinent hardware issues.

Included CD-Rom contains all the source code used in the design examples, so engineers can easily use it in their own designs

Spis treści

Cover 2
Acknowledgements 7
Contents 9
Preface 17
I. Basic Hardware 19
- I. Introduction 21
- Chapter 1. Basic Electronics 23
  - DC Circuits 23
  - AC Circuits 32
  - Active Devices 38
  - Putting it Together—a Power Supply 42
  - The Scope 45
- Chapter 2. Logic Circuits 51
  - Coding 51
  - Combinatorial Logic 54

Cover 2
Acknowledgements 7
Contents 9
Preface 17
I. Basic Hardware 19
- I. Introduction 21
- Chapter 1. Basic Electronics 23
  - DC Circuits 23
  - AC Circuits 32
  - Active Devices 38
  - Putting it Together—a Power Supply 42
  - The Scope 45
- Chapter 2. Logic Circuits 51
  - Coding 51
  - Combinatorial Logic 54
  - Sequential Logic 61
  - Logic Wrap-up 65
- Chapter 3. Hardware Design Tips 67
  - Diagnostics 67
  - Connecting Tools 68
  - Other Thoughts 69
  - Summary 70
- II. Designs 71
  - II. Introduction 73
  - Chapter 4. Tools and Methods for Improving Code Quality 75
    - Introduction 75
    - The Traditional Serial Development Cycle of an Embedded Design 75
    - Typical Challenges in Today’s Embedded Market 76
    - Generic Methods to Improve Code Quality and Reduce the Time-to-Market 77
    - Major Time Factors for the Engineering Cycle 78
    - Where is Most Time Needed? 78
    - How to Improve Software Development Time and Code Quality 78
    - How to Reduce Hardware Development Time 82
    - Outlook and Summary 83
  - Chapter 5. Tips to Improve Functions 87
    - Minimize Functionality 87
    - Remove Redundancies 88
    - Encapsulate 88
    - Reduce Real-Time Code 89
    - Flow With Grace 89
    - Refactor Relentlessly 90
    - Employ Standards and Inspections 90
    - Comment Carefully 91
    - Summary 93
  - Chapter 6. Evolutionary Development 95
    - Introduction 95
    - 1. History 96
    - 2. Issues Addressed by Evo 98
    - 3. How Do We Use Evo in Projects 107
    - 4. Check Lists 110
    - 5. Introducing Evo in New Projects 112
    - 6. Testing With Evo 113
    - 7. Change Requests and Problem Reports 114
    - 8. Tools 115
    - 9. Conclusion 116
    - References 117
    - Acknowledgment 117
  - Chapter 7. Embedded State Machine Implementation 119
    - State Machines 119
    - An Example 120
    - Implementation 122
    - Testing 126
    - Crank It 126
    - References 127
  - Chapter 8. Hierarchical State Machines 129
    - Conventional State Machine Example 130
    - Hierarchical State Machine Example 132
  - Chapter 9. Developing Safety Critical Applications 139
    - Reliability and safety 139
    - Introduction 139
    - Along came DO-178B 140
    - Failure Condition Categorization 141
    - Overview of DO-178B 141
    - System Architectural Considerations 143
    - DO-178B Software life cycle 144
    - System Architectural Documentation 144
    - Object Oriented Technology and Safety Critical Software Challenges 149
    - Iterative Process 150
    - Issues Facing OO Certification 151
    - References 154
    - Summary 154
  - Chapter 10. Installing and Using a Version Control System 155
    - Introduction 155
    - The Power and Elegance of Simplicity 156
    - Version Control 156
    - Typical Symptoms of Not (Fully) Utilizing a Version Control System 157
    - Simple Version Control Systems 157
    - Advanced Version Control Systems 157
    - What Files to Put Under Version Control 158
    - Sharing of Files and the Version Control Client 158
    - Graphical User Interface (GUI) Issues 159
    - Integrated Development Environment Issues 159
    - World Wide Web Browser Interface or Java Version Control Client 160
    - Common Source Code Control Specification 160
    - Bug Tracking 167
    - Non-Configuration Management Tools 168
    - Closing Comments 169
    - Suggested Reading, References, and Resources 170
  - III. Math 173
    - III. Introduction 175
    - Chapter 11. An Introduction To Machine Calculations 177
      - Introduction 177
      - Integer Arithmetic 177
      - Floating-Point Math 183
      - Fixed-Point Arithmetic 194
      - Conclusion 197
      - Bibliography 197
    - Chapter 12. Floating Point Approximations 199
      - Cosine and Sine 200
      - General Trig Notes 200
      - Higher Precision Cosines 207
      - Tangent 208
      - Higher Precision Tangents 213
      - Arctangent, Arcsine and Arccosine 214
    - Chapter 13. Math Functions 219
      - Computing an Exclusive Or 219
      - Gray Code 219
      - Integer Multiplication by a Constant 219
      - Integer Square Roots 220
      - Important Basic Math Operations 220
    - Chapter 14. IEEE 754 Floating Point Numbers 221
      - Special values 222
    - IV. Real-Time 225
      - IV. Introduction 227
      - Chapter 15. Real-Time Kernels 229
        
        Introduction 229
        
        What is a Real-Time Kernel? 229
        
        What is a task? 230
        
        The Clock Tick 233
        
        Scheduling 234
        
        Context Switching 236
        
        Kernel Services 237
        
        Kernel Services, Semaphores 237
        
        Kernel Services, Message Queues 241
        
        Kernel Services, Memory Management 243
        
        Do You Need a Kernel? 243
        
        Can You Use a Kernel? 244
        
        Selecting a Kernel? 245
        
        Conclusion 247
      - Chapter 16. Reentrancy 249
        
        Atomic Variables 249
        
        Two More Rules 251
        
        Keeping Code Reentrant 252
        
        Recursion 253
        
        Asynchronous Hardware/Firmware 254
        
        Race Conditions 255
        
        Options 256
        
        Other RTOSes 257
        
        Metastable States 258
        
        Firmware, not Hardware 260
      - Chapter 17. Interrupt Latency 263
        
        Taking Data 266
      - Chapter 18. Understanding Your C Compiler: How to Minimize Code Size 269
        
        Modern C Compilers 270
        
        Tips on Programming 277
        
        Final Notes 283
        
        Acknowledgements 284
      - Chapter 19. Optimizing C and C++ Code 285
        
        Place Frequent Case Labels First 285
        
        Adjust Structure Sizes to Power of Two 285
        
        Place Case Labels in Narrow Range 285
        
        Break Big Switch Statements into Nested Switches 286
        
        Use References for Parameter Passing and Return Value for Types Bigger than 4 Bytes 287
        
        Declare Local Variables in the Innermost Scope 287
        
        Reduce the Number of Parameters 287
        
        Minimize Local Variables 287
        
        Prefer int over char and short 288
        
        Don’t Define a Return Value if Not Used 288
        
        Consider Locality of Reference for Code and Data 288
        
        Define Lightweight Constructors 289
        
        Use Constructor Initialization Lists 290
        
        Prefer Initialization Over Assignment 290
        
        Inline 1 to 3 Line Functions 291
        
        Do Not Declare “Just in Case” Virtual Functions 291
      - Chapter 20. Real-Time Asserts 293
        
        Embedded Issues 293
        
        Real-Time Asserts 294
      - V. Errors and Changes 299
        
        V. Introduction 301
        
        Chapter 21. Implementing Downloadable Firmware With Flash Memory 303
        
        Introduction 303
        
        The Microprogrammer 304
        
        Advantages of Microprogrammers 304
        
        Receiving a Microprogrammer 305
        
        Disadvantages of Microprogrammers 305
        
        A Basic Microprogrammer 306
        
        Common Problems and Their Solutions 307
        
        Hardware Alternatives 313
        
        Separating Code and Data 313
        
        Chapter 22. Memory Diagnostics 317
        
        ROM Tests 317
        
        RAM Tests 319
        
        Chapter 23. Nonvolatile Memory 325
        
        Supervisory Circuits 325
        
        Multi-byte Writes 327
        
        Testing 329
        
        Conclusion 330
        
        Chapter 24. Proactive Debugging 331
        
        Stacks and Heaps 331
        
        Seeding Memory 333
        
        Wandering Code 334
        
        Special Decoders 336
        
        MMUs 336
        
        Conclusion 337
        
        Chapter 25. Exception Handling in C++ 339
        
        The Mountains (Landmarks of Exception Safety) 340
        
        A History of this Territory 341
        
        The Tar Pit 342
        
        Tar! 344
        
        The Royal Road 344
        
        The Assignment Operator—A Special Case 346
        
        In Bad Weather 347
        
        Looking back 350
        
        References 355
        
        Chapter 26. Building a Great Watchdog 357
        
        Internal WDTs 360
        
        External WDTs 361
        
        Characteristics of Great WDTs 363
        
        Using an Internal WDT 365
        
        An External WDT 367
        
        WDTs for Multitasking 368
        
        Summary and Other Thoughts 370
        
        Appendix A: ASCII Table 373
        
        Appendix B: Byte Alignment and Ordering 375
        
        Byte Alignment Restrictions 375
        
        Byte Ordering 377
        
        Index 379

Pokaż więcej

Afiljacja autora

Jack Ganssle: Founder and Principal Consultant, The Ganssle

Opis

Spis treści

Recenzje (0)

Afiljacja autora