Assembly Language Using the Raspberry Pi: A Hardware Software Bridge

by Robert Dunne

Overview

Programmers learn by example and develop their skills by examining and modifying working programs. Assembly Language Using the Raspberry Pi is a complete tutorial that provides working example programs to introduce the novice to both CPU hardware and professional software development methods.

• Each of the 20 chapters begins with a complete sample program to examine and test, followed by a description explaining the programming techniques and instructions that are introduced.
• The first program is only 5 lines of code while later ones consist of over 100 lines.
• Every sample program is complete, but leaves room for enhancements and experimentation encouraged by the questions at the end of each chapter.
• ARM processor instructions and features are introduced as needed to implement the increased complexity in programming techniques.
• There is an emphasis on program structure and design patterns that facilitate developing maintainable code (i.e., no spaghetti code).
• The sample programs are documented both in flow diagrams and in comments.
• Over 100 illustrations are included to explain programming techniques as well as ARM and floating point instructions.
• Floating point format and instructions are covered extensively, but gradually introduced through a series of seven chapters covering IEEE 754, VFPv3, and NEON.
• Background material on subjects like binary, two’s complement, and hexadecimal appear in fourteen appendices for those who need it, without getting in the way of programmers who don’t.
• This book has been “classroom tested” with students having very little if any previous programming experience. The information is complete, allowing it to also be used as an independent study.
• All system and utility software used in the book is included in the standard Raspian Linux distribution intended to be used with the Raspberry Pi 2 and 3.

Assembly language is the computer programming language closest to a computer’s “machine code language.” Learning to program in assembly language is an excellent practical “hands-on” introduction to the details of computer architecture. Although applications and systems software written in assembly language were once common, assembly language is now primarily a bridge of understanding between computer architects and software developers.

Product Details

ISBN-13:	9780970112422
Publisher:	Gaul Communications
Publication date:	06/20/2017
Pages:	414
Product dimensions:	7.00(w) x 10.00(h) x 0.94(d)

About the Author

Robert Dunne has over 40 years of computer experience ranging from developing custom hardware interfaces on supercomputers to teaching technology courses in middle-school gifted-education programs. Starting out with degrees in physics and computer science, he was on staff at a national laboratory and a major engineering firm for ten years before becoming an entrepreneur in the development of embedded systems. Before working with the ARM architecture and Raspberry Pi, he had written well over 100,000 lines of assembler code developing systems and applications on nine unique CPU architectures encompassing mainframes, minicomputers, and microcomputers. During the past ten years, he has taught three undergraduate courses per semester in digital electronics and embedded systems and is notorious for getting his students working on a lab project within the first 60 seconds of the very first class meeting.

Table of Contents

Preface

Audience for This Book

Why the Raspberry Pi?

Why Assembly Language and Why Now?

0: Introduction

The Machine and Its Language

Registers

Op-codes

Language Interpreter and Compiler

Documentation

Debugging

1: Compile, Link, Execute

Your Program Is Not Alone

2: Arithmetic Logic Unit

ARM Registers

Logical Operations

Bit Shift Operations

3: Subroutines and ASCII Output

Linux Services

Subroutines

Functions, Methods, Procedures

Interrupts

Link Register (LR)

4: True and False

Program Counter (PC) Register

Current Program Status Register (CPSR)

Stack Pointer (SP) Register

5: Display Numbers in Binary

Why Binary?

A Loop Through 32 Binary Digits (Bits)

AND R1,R4,R3,LSR R6

6: Display Numbers in Hexadecimal

Why Hexadecimal?

Word Addressable or Byte Addressable?

Multiplying and Dividing by Shifting

Arrays

7: Display Numbers in Decimal

Nested Loops

LDR R5,[R6],#4

Nested Loops Code Example

8: Data Types and Storage

Harvard and Von Neumann

Base Registers

Indexed Addressing

Big and Little Endian

Alignment

Block Transfers

9: Disassembler

Macros

Second Operand

Emulator

10: Fixed Point

Whole Numbers and Integers

Review Questions

11: Binary Point

Other Bases

When Is Enough Enough?

12: Floating Point Display

Scientific Notation

Normalization

Conversion to IEEE 754 Floating Point

Significant or Mantissa?

13: Floating Point Coprocessor

Not a Number (NaN)

NEON or VFPv3

14: Precision

Accuracy and Precision

Dot Product

15: Performance Using Vectors

VFPv3 Banks, Len, and Stride

NEON Coprocessor

Lanes

Saturation

Promotions and Demotions

Interleaved storage

NEON Integer Operations

16: Text and Logical Input

Call by Name

17: Integer Input

Integers Input in Different Bases

Thumb Code

18: Floating Point Input

19: Model View Controller

Epilogue

A: Raspberry Pi Setup

GNU Assembler

Configuration

B: Binary Numbers

Nine’s complement

One’s complement

Two’s complement

C: Hexadecimal Numbers

D: ASCII

E: Text Editors

Leafpad Editor

Nano Editor

vi Editor

F: ARM Instructions

G: Vector & Floating Point Instructions

H: Assembler Directives

I: Linux Service Calls

J: GDB Debugger Commands

K: Command Lines

L: C Programming

M: Electronic Interfaces

I/O Processor

Virtual Files

N: Thumb Code

Answers to Selected Questions