Fundamentals of Embedded Software with the ARM Cortex-M3 (2nd Edition)

Description

For sophomore-level courses in Assembly Language Programming in Computer Science, Embedded Systems Design, Real-Time Analysis, Computer Engineering, or Electrical Engineering curricula. Requires prior knowledge of C, C++, or Java.

Allows instructors to easily introduce embedded systems into an already packed curriculum, and provides a way to cover the procedural style still necessary in upper-division courses.

This book is intended to provide a highly motivating context in which to learn procedural programming languages. The ultimate goal of this text is to lay a foundation that supports the multi-threaded style of programming and high-reliability requirements of embedded software. It presents assembly the way it is most commonly used in practice – to implement small, fast, or special-purpose routines called from a main program written in a high-level language such as C. Students not only learn that assembly still has an important role to play, but their discovery of multi-threaded programming, preemptive and non-preemptive systems, shared resources, and scheduling helps sustain their interest, feeds their curiosity, and strengthens their preparation for subsequent courses on operating systems, real-time systems, networking, and microprocessor-based design.

Table of Contents

1. Part 1 Introduction        
   1. WHAT IS AN EMBEDDED SYSTEM?
   2. WHAT’S UNIQUE ABOUT THE DESIGN GOALS FOR EMBEDDED SOFTWARE?
   3. What Does “Real-Time” Mean?
   4. What Does “multithreading” mean?
   5. HOW POWERFUL ARE EMBEDDED PROCESSORS?
   6. WHAT PROGRAMMING LANGUAGES ARE USED?
   7. HOW IS BUILDING AN EMBEDDED APPLICATION DIFFERENT?
   8. HOW BIG ARE TYPICAL EMBEDDED PROGRAMS?
   9. PROBLEMS
2. Part 2 Data Representation
   1. FIXED-PRECISION BINARY NUMBERS
   2. POSITIONAL NUMBER SYSTEMS
   3. Binary-to-Decimal Conversion
   4. Decimal-to-Binary Conversion
   5. Hexadecimal — A Shorthand for Binary
   6. Fixed Precision, Rollover and Overflow
   7. BINARY REPRESENTATION OF INTEGERS
   8. Signed Integers
   9. Positive and Negative Representations of the Same Magnitude
   10. Interpreting the Value of a 2’s-Complement Number
   11. Changing the Sign of Numbers with Integer and Fractional Parts
   12. Binary Addition and Subtraction
   13. Range and Overflow
   14. BINARY REPRESENTATION OF REAL NUMBERS
   15. Floating-Point Real Numbers
   16. Fixed-Point Real Numbers
   17. ASCII REPRESENTATION OF TEXT
   18. BINARY-CODED DECIMAL (BCD)
   19. PROBLEMS
3. Part 3 Implementing Arithmetic        
   1. 2’s Complement and hardware complexity
   2. MULTIPLICATION AND DIVISION
   3. Signed vs. Unsigned Multiplication
   4. Shifting Instead of Multiplying or Dividing by Powers of 2
   5. Multiplying by an Arbitrary Constant
   6. Dividing by an Arbitrary Constant
   7. ARITHMETIC FOR FIXED-POINT REALS
   8. Fixed-Point Using a Universal 16.16 Format
   9. Fixed-Point Using a Universal 32.32 Format
   10. Multiplication of 32.32 Fixed Point Reals
   11. Example: Multiplying two 4.4 Fixed Point Reals
   12. PROBLEMS
4. Part 4 Getting the Most Out of C       
   1. Integer Data Types
   2. Integer Range and the Standard Header File LIMITS.H
   3. BOOLEAN Data Types
   4. Mixing Data Types
   5. Manipulating Bits in Memory
   6. Testing Bits
   7. Setting, Clearing, and Inverting Bits
   8. Extracting Bits
   9. Inserting Bits
   10. Manipulating Bits in INPUT/OUTPUT PORTS
   11. Write-Only I/O Devices
   12. I/O Devices Differentiated by Reads Versus Writes
   13. I/O Devices Differentiated by Sequential Access
   14. I/O Devices Differentiated by Bits in the Written Data
   15. Accessing Memory-Mapped I/O Devices
   16. Accessing Data Using a Pointer
   17. Arrays, Pointers, and the “Address of” Operator
   18. Structures
   19. Packed Structures
   20. Bit Fields
   21. Variant Access
   22. Casting the Address of an Object
   23. Using Unions
   24. Problems
5. Part 5 Programming in Assembly
   1. Part 1: Computer Organization
   2. Memory
   3. Data Alignment
   4. The Central Processing Unit (CPU)
   5. Other Registers
   6. The Fetch-Execute Cycle
   7. Input/Output (I/O)
   8. Introduction to the ARM® CortexTM- M3 V7M Architecture
   9. Internal Organization
   10. Instruction Pipelining
   11. Memory Model
   12. Bit-Banding
   13. ARM ASSEMBLY LANGUAGE
   14. Instruction Formats and Operands
   15. Translating Assembly into Binary
   16. Problems
6. Part 6 Programming in Assembly
   1. Part 2: Data Manipulation
   2. LOADING CONSTANTS INTO REGISTERS
   3. LOADING MEMORY DATA INTO REGISTERS
   4. STORING DATA FROM REGISTERS TO MEMORY
   5. CONVERTING SIMPLE C ASSIGNMENT STATEMENTS INTO ARM ASSEMBLY
   6. MEMORY ADDRESS CALCULATIONS
   7. MEMORY ADDRESSING EXAMPLES
   8. Translating C Pointer Expressions to Assembly
   9. Translating C Subscript Expressions to Assembly
   10. Translating Structure References to Assembly
   11. STACK INSTRUCTIONS
   12. DATA PROCESSING INSTRUCTIONS
   13. Updating the Flags in the APSR
   14. Arithmetic Instructions
   15. Bit Manipulation Instructions
   16. Shift Instructions
   17. Bitfield Manipulation Instructions
   18. Miscellaneous Bit, Byte and Halfword Instructions
   19. PROBLEMS
7. Part 7 Programming in Assembly
   1. Part 3: Control Structures
   2. INSTRUCTION SEQUENCING
   3. IMPLEMENTING DECISIONS
   4. Conditional Branch Instructions
   5. If-Then and If-Then-Else Statements
   6. Compound Conditionals
   7. The “If-Then” (IT) Instruction
   8. IMPLEMENTING LOOPS
   9. Speeding Up Array Access
   10. IMPLEMENTING FUNCTIONS
   11. Function Call and Return
   12. Register Usage
   13. Parameter Passing
   14. Return Values
   15. Temporary Variables
   16. Preserving Registers
   17. PROBLEMS
8. Part 8 Programming in Assembly
   1. Part 4: I/O Programming
   2. THE CORTEX-M3 I/O HARDWARE
   3. Interrupts and Exceptions
   4. Thread and Handler Modes
   5. Entering the Exception Handler
   6. Returning from the Exception Handler
   7. Latency Reduction
   8. Priorities and Nested Exceptions
   9. SYNCHRONIZATION, TRANSFER RATE, AND LATENCY
   10. BUFFERS AND QUEUES
   11. Double Buffering
   12. ESTIMATING I/O PERFORMANCE CAPABILITY
   13. Polled Waiting Loops
   14. Interrupt-Driven I/O
   15. Direct Memory Access
   16. Comparison of Methods
   17. PROBLEMS
9. Part 9 Concurrent Software
   1. FOREGROUND/BACKGROUND SYSTEMS
   2. Thread State and Serialization
   3. Managing Latency
   4. Interrupt Overrun
   5. Moving Work into the Background
   6. MULTI-THREADED PROGRAMMING
   7. Concurrent Execution of Independent Threads
   8. Context Switching
   9. Non-preemptive (Cooperative) Multithreading
   10. Preemptive Multithreading
   11. SHARED RESOURCES AND CRITICAL SECTIONS
   12. Disabling Interrupts
   13. Disabling Task Switching
   14. Spin Locks
   15. Mutex Objects
   16. Semaphores
   17. PROBLEMS
10. Part 10 Scheduling
11. 1. THREAD STATES
    2. PENDING THREADS
    3. CONTEXT SWITCHING
    4. ROUND-ROBIN SCHEDULING
    5. PRIORITY-BASED SCHEDULING
    6. Resource Starvation
    7. Priority Inversion
    8. The Priority Ceiling Protocol
    9. The Priority Inheritance Protocol
    10. ASSIGNING PRIORITIES
    11. Deadline-Driven Scheduling
    12. Rate-Monotonic Scheduling
    13. DEADLOCK
    14. WATCHDOG TIMERS
    15. PROBLEMS
12. Part 11 Memory Management
    1. OBJECTS IN C
    2. SCOPE
    3. Refining Local Scope
    4. Refining Global Scope
    5. LIFETIME
    6. AUTOMATIC ALLOCATION
    7. Storage Class “Register”
    8. STATIC ALLOCATION
    9. THREE PROGRAMS TO DISTINGUISH STATIC FROM AUTOMATIC
    10. Object Creation
    11. Object Initialization
    12. Object Destruction
    13. DYNAMIC ALLOCATION
    14. Fragmentation
    15. Memory Allocation Pools
    16. AUTOMATIC ALLOCATION WITH VARIABLE SIZE (alloca)
    17. Variable-Size Arrays
    18. RECURSIVE FUNCTIONS AND MEMORY ALLOCATION
    19. PROBLEMS
13. Part 12 Shared Memory
    1. RECOGNIZING SHARED OBJECTS
    2. REENTRANT FUNCTIONS
    3. READ-ONLY DATA
    4. Type Qualifier “const”
    5. CODING PRACTICES TO AVOID
    6. Functions That Keep Internal State in Local Static Objects
    7. Functions That Return the Address of a Local Static Object
    8. ACCESSING SHARED MEMORY
    9. The Effect of Processor Architecture
    10. Read-Only and Write-Only Access
    11. Type Qualifier “volatile”
    12. PROBLEMS
14. Part 13 System Initialization
    1. MEMORY LAYOUT
    2. THE CPU AND VECTOR TABLE
    3. C RUN-TIME ENVIRONMENT
    4. Copying Initial Values from Non-Volatile Memory into the Data Region
    5. Zeroing Uninitialized Statics
    6. Setting Up a Heap
    7. SYSTEM TIMER
    8. OTHER PERIPHERAL DEVICES