Firmware Handbook (eBook)

Cover 1
TOC$Contents 8
Acknowledgements 6
Contents 8
Preface 16
I. Basic Hardware 18
I. Introduction 20
CH$1. Basic Electronics 22
DC Circuits 22
AC Circuits 31
Active Devices 37
Putting it Together—a Power Supply 41
The Scope 44
CH$2. Logic Circuits 50
Coding 50
Combinatorial Logic 53
Sequential Logic 60
Logic Wrap-up 64
CH$3. Hardware Design Tips 66
Diagnostics 66
Connecting Tools 67
Other Thoughts 68
Summary 69
II. Designs 70
II. Introduction 72
CH$4. Tools and Methods for Improving Code Quality 74
Introduction 74
The Traditional Serial Development Cycle of an Embedded Design 74
Typical Challenges in Today’s Embedded Market 75
Generic Methods to Improve Code Quality and Reduce the Time-to-Market 76
Major Time Factors for the Engineering Cycle 77
Where is Most Time Needed? 77
How to Improve Software Development Time and Code Quality 77
How to Reduce Hardware Development Time 81
Outlook and Summary 82
CH$5. Tips to Improve Functions 86
Minimize Functionality 86
Encapsulate 87
Remove Redundancies 87
Reduce Real-Time Code 88
Flow With Grace 88
Refactor Relentlessly 89
Employ Standards and Inspections 89
Comment Carefully 90
Summary 92
CH$6. Evolutionary Development 94
Introduction 94
1. History 95
2. Issues Addressed by Evo 97
3. How Do We Use Evo in Projects 106
4. Check Lists 109
5. Introducing Evo in New Projects 111
6. Testing With Evo 112
7. Change Requests and Problem Reports 113
8. Tools 114
9. Conclusion 115
Acknowledgment 116
References 116
CH$7. Embedded State Machine Implementation 118
State Machines 118
An Example 119
Implementation 121
Testing 125
Crank It 125
References 126
CH$8. Hierarchical State Machines 128
Conventional State Machine Example 129
Hierarchical State Machine Example 131
CH$9. Developing Safety Critical Applications 138
Introduction 138
Reliability and safety 138
Along came DO-178B 139
Overview of DO-178B 140
Failure Condition Categorization 140
System Architectural Considerations 142
System Architectural Documentation 143
DO-178B Software life cycle 143
Object Oriented Technology and Safety Critical Software Challenges 148
Iterative Process 149
Issues Facing OO Certification 150
Summary 153
References 153
CH$10. Installing and Using a Version Control System 154
Introduction 154
The Power and Elegance of Simplicity 155
Version Control 155
Typical Symptoms of Not (Fully) Utilizing a Version Control System 156
Simple Version Control Systems 156
Advanced Version Control Systems 156
What Files to Put Under Version Control 157
Sharing of Files and the Version Control Client 157
Integrated Development Environment Issues 158
Graphical User Interface (GUI) Issues 158
Common Source Code Control Specification 159
World Wide Web Browser Interface or Java Version Control Client 159
Bug Tracking 166
Non-Configuration Management Tools 167
Closing Comments 168
Suggested Reading, References, and Resources 169
III. Math 172
III. Introduction 174
CH$11. An Introduction To Machine Calculations 176
Introduction 176
Integer Arithmetic 176
Floating-Point Math 182
Fixed-Point Arithmetic 193
Conclusion 196
Bibliography 196
CH$12. Floating Point Approximations 198
General Trig Notes 199
Cosine and Sine 199
Higher Precision Cosines 206
Tangent 207
Higher Precision Tangents 212
Arctangent, Arcsine and Arccosine 213
CH$13. Math Functions 218
Gray Code 218
Integer Multiplication by a Constant 218
Computing an Exclusive Or 218
Integer Square Roots 219
Important Basic Math Operations 219
CH$14. IEEE 754 Floating Point Numbers 220
Special values 221
IV. Real-Time 224
IV. Introduction 226
CH$15. Real-Time Kernels 228
Introduction 228
What is a Real-Time Kernel? 228
What is a task? 229
The Clock Tick 232
Scheduling 233
Context Switching 235
Kernel Services 236
Kernel Services, Semaphores 236
Kernel Services, Message Queues 240
Kernel Services, Memory Management 242
Do You Need a Kernel? 242
Can You Use a Kernel? 243
Selecting a Kernel? 244
Conclusion 246
CH$16. Reentrancy 248
Atomic Variables 248
Two More Rules 250
Keeping Code Reentrant 251
Recursion 252
Asynchronous Hardware/Firmware 253
Race Conditions 254
Options 255
Other RTOSes 256
Metastable States 257
Firmware, not Hardware 259
CH$17. Interrupt Latency 262
Taking Data 265
CH$18. Understanding Your C Compiler: How to Minimize Code Size 268
Modern C Compilers 269
Tips on Programming 276
Final Notes 282
Acknowledgements 283
CH$19. Optimizing C and C++ Code 284
Adjust Structure Sizes to Power of Two 284
Place Case Labels in Narrow Range 284
Place Frequent Case Labels First 284
Break Big Switch Statements into Nested Switches 285
Minimize Local Variables 286
Declare Local Variables in the Innermost Scope 286
Reduce the Number of Parameters 286
Use References for Parameter Passing and Return Value for Types Bigger than 4 Bytes 286
Don’t Define a Return Value if Not Used 287
Consider Locality of Reference for Code and Data 287
Prefer int over char and short 287
Define Lightweight Constructors 288
Prefer Initialization Over Assignment 289
Use Constructor Initialization Lists 289
Do Not Declare “Just in Case” Virtual Functions 290
Inline 1 to 3 Line Functions 290
CH$20. Real-Time Asserts 292
Embedded Issues 292
Real-Time Asserts 293
V. Errors and Changes 298
V. Introduction 300
CH$21. Implementing Downloadable Firmware With Flash Memory 302
Introduction 302
The Microprogrammer 303
Advantages of Microprogrammers 303
Disadvantages of Microprogrammers 304
Receiving a Microprogrammer 304
A Basic Microprogrammer 305
Common Problems and Their Solutions 306
Hardware Alternatives 312
Separating Code and Data 312
CH$22. Memory Diagnostics 316
ROM Tests 316
RAM Tests 318
CH$23. Nonvolatile Memory 324
Supervisory Circuits 324
Multi-byte Writes 326
Testing 328
Conclusion 329
CH$24. Proactive Debugging 330
Stacks and Heaps 330
Seeding Memory 332
Wandering Code 333
Special Decoders 335
MMUs 335
Conclusion 336
CH$25. Exception Handling in C++ 338
The Mountains (Landmarks of Exception Safety) 339
A History of this Territory 340
The Tar Pit 341
Tar! 343
The Royal Road 343
The Assignment Operator—A Special Case 345
In Bad Weather 346
Looking back 349
References 354
CH$26. Building a Great Watchdog 356
Internal WDTs 359
External WDTs 360
Characteristics of Great WDTs 362
Using an Internal WDT 364
An External WDT 366
WDTs for Multitasking 367
Summary and Other Thoughts 369
Appendix A: ASCII Table 372
Appendix B: Byte Alignment and Ordering 374
Byte Alignment Restrictions 374
Byte Ordering 376
IDX$Index 378