O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

The Definitive Guide to the ARM Cortex-M3

Book Description

This user's guide does far more than simply outline the ARM Cortex-M3 CPU features; it explains step-by-step how to program and implement the processor in real-world designs. It teaches readers how to utilize the complete and thumb instruction sets in order to obtain the best functionality, efficiency, and reuseability. The author, an ARM engineer who helped develop the core, provides many examples and diagrams that aid understanding. Quick reference appendices make locating specific details a snap!

Whole chapters are dedicated to:
Debugging using the new CoreSight technology
Migrating effectively from the ARM7
The Memory Protection Unit
Interfaces, Exceptions,Interrupts
...and much more!

*The only available guide to programming and using the groundbreaking ARM Cortex-M3 processor

*Easy-to-understand examples, diagrams, quick reference appendices, full instruction and Thumb-2 instruction sets are all included

*The author, an ARM engineer on the M3 development team, teaches end users how to start from the ground up with the M3, and how to migrate from the ARM7

Table of Contents

  1. Cover
  2. Title Page
  3. Copyright
  4. Foreword
  5. Preface
  6. Acknowledgments
  7. Terms and Abbreviations
  8. Conventions
  9. References
  10. Table of Contents
  11. Chapter 1: Introduction
    1. What Is the ARM Cortex-M3 Processor?
    2. Background of ARM and ARM Architecture
    3. Instruction Set Development
    4. The Thumb-2 Instruction Set Architecture (ISA)
    5. Cortex-M3 Processor Applications
    6. Organization of This Book
    7. Further Readings
  12. Chapter 2: Overview of the Cortex-M3
    1. Fundamentals
    2. Registers
    3. Operation Modes
    4. The Built-In Nested Vectored Interrupt Controller
    5. The Memory Map
    6. The Bus Interface
    7. The Memory Protection Unit
    8. The Instruction Set
    9. Interrupts and Exceptions
    10. Debugging Support
    11. Characteristics Summary
  13. Chapter 3: Cortex-M3 Basics
    1. Registers
    2. Special Registers
    3. Operation Mode
    4. Exceptions and Interrupts
    5. Vector Tables
    6. Stack Memory Operations
    7. Reset Sequence
  14. Chapter 4: Instruction Sets
    1. Assembly Basics
    2. Instruction List
    3. Instruction Descriptions
    4. Several Useful Instructions in the Cortex-M3
  15. Chapter 5: Memory Systems
    1. Memory System Features Overview
    2. Memory Maps
    3. Memory Access Attributes
    4. Default Memory Access Permissions
    5. Bit-Band Operations
    6. Unaligned Transfers
    7. Exclusive Accesses
    8. Endian Mode
  16. Chapter 6: Cortex-M3 Implementation Overview
    1. The Pipeline
    2. A Detailed Block Diagram
    3. Bus Interfaces on the Cortex-M3
    4. Other Interfaces on the Cortex-M3
    5. The External Private Peripheral Bus
    6. Typical Connections
    7. Reset Signals
  17. Chapter 7: Exceptions
    1. Exception Types
    2. Definitions of Priority
    3. Vector Tables
    4. Interrupt Inputs and Pending Behavior
    5. Fault Exceptions
    6. SVC and PendSV
  18. Chapter 8: The NVIC and Interrupt Control
    1. NVIC Overview
    2. The Basic Interrupt Configuration
    3. Interrupt Enable and Clear Enable
    4. Interrupt Pending and Clear Pending
    5. Example Procedures in Setting Up an Interrupt
    6. Software Interrupts
    7. The SYSTICK Timer
  19. Chapter 9: Interrupt Behavior
    1. Interrupt/Exception Sequences
    2. Exception Exits
    3. Nested Interrupts
    4. Tail-Chaining Interrupts
    5. Late Arrivals
    6. More on the Exception Return Value
    7. Interrupt Latency
    8. Faults Related to Interrupts
  20. Chapter 10: Cortex-M3 Programming
    1. Overview
    2. The Interface Between Assembly and C
    3. A Typical Development Flow
    4. The First Step
    5. Producing Outputs
    6. Using Data Memory
    7. Using Exclusive Access for Semaphores
    8. Using Bit-Band for Semaphores
    9. Working with Bit Field Extract and Table Branch
  21. Chapter 11: Exceptions Programming
    1. Using Interrupts
    2. Exception/Interrupt Handlers
    3. Software Interrupts
    4. Example with Exception Handlers
    5. Using SVC
    6. SVC Example: Use for Output Functions
    7. Using SVC with C
  22. Chapter 12: Advanced Programming Features and System Behavior
    1. Running a System with Two Separate Stacks
    2. Double-Word Stack Alignment
    3. Nonbase Thread Enable
    4. Performance Considerations
    5. Lockup Situations
  23. Chapter 13: The Memory Protection Unit
    1. Overview
    2. MPU Registers
    3. Setting Up the MPU
    4. Typical Setup
  24. Chapter 14: Other Cortex-M3 Features
    1. The SYSTICK Timer
    2. Power Management
    3. Multiprocessor Communication
    4. Self-Reset Control
  25. Chapter 15: Debug Architecture
    1. Debugging Features Overview
    2. CoreSight Overview
    3. Debug Modes
    4. Debugging Events
    5. Breakpoint in the Cortex-M3
    6. Accessing Register Content in Debug
    7. Other Core Debugging Features
  26. Chapter 16: Debugging Components
    1. Introduction
    2. Trace Components: Data Watchpoint and Trace
    3. Trace Components: Instrumentation Trace Macrocell
    4. Trace Components: Embedded Trace Macrocell
    5. Trace Components: Trace Port Interface Unit
    6. The Flash Patch and Breakpoint Unit
    7. The AHB Access Port
    8. ROM Table
  27. Chapter 17: Getting Started with Cortex-M3 Development
    1. Choosing a Cortex-M3 Product
    2. Differences Between Cortex-M3 Revision 0 and Revision 1
    3. Development Tools
  28. Chapter 18: Porting Applications from the ARM7 to the Cortex-M3
    1. Overview
    2. System Characteristics
    3. Assembly Language Files
    4. C Program Files
    5. Precompiled Object Files
    6. Optimization
  29. Chapter 19: Starting Cortex-M3 Development Using the GNU Tool Chain
    1. Background
    2. Getting the GNU Tool Chain
    3. Development Flow
    4. Examples
    5. Accessing Special Registers
    6. Using Unsupported Instructions
    7. Inline Assembler in the GNU C Compiler
  30. Chapter 20: Getting Started with the KEIL RealView Microcontroller Development Kit
    1. Overview
    2. Getting Started with μVision
    3. Outputting the “Hello World” Message Via UART
    4. Testing the Software
    5. Using the Debugger
    6. The Instruction Set Simulator
    7. Modifying the Vector Table
    8. Stopwatch Example with Interrupts
  31. APPENDIX A: Cortex-M3 Instructions Summary
    1. Supported 16-Bit Thumb Instructions
    2. Supported 32-Bit Thumb-2 Instructions
  32. APPENDIX B: 16-Bit Thumb Instructions and Architecture Versions
  33. APPENDIX C: Cortex-M3 Exceptions Quick Reference
    1. Exception Types and Enables
    2. Stack Contents After Exception Stacking
  34. APPENDIX D: NVIC Registers Quick Reference
  35. APPENDIX E: Cortex-M3 Troubleshooting Guide
    1. Overview
    2. Developing Fault Handlers
    3. Other Possible Problems
  36. Index
  37. Instructions for online access