1. Overview of ARM assembly programming and addressing modes
2. ARM assembly programming using Arithmetic Instructions
3. ARM assembly programming using control flow instructions I
4. Introduction to STM micro-controller, ARM architecture and its programming in Keil
5. STM32 GPIO Port familiarization using blinking LED example
6. Keypad and Seven-Segment Display Interface with STM32F103
7. Mid Term Exam
8. 16x2 LCD Interface with STM32F103
9. ADC Interface with STM32F103
10. PWM generation & Motor Speed control using STM32F103
11. External Interrupts of STM32F103
12. Complex Engineering Problem I
13. Complex Engineering Problem II
14. Final
iv Lab Number: 1
Lab Title: Overview of ARM processor’s assembly programming and Addressing modes
DEPARTMENT OF COMPUTING
v Experiment No 1 Overview of ARM processor’s assembly programming and Addressing modes 1.1 Objectives
• To learn basics of assembly language and start simulation on Keil.
• To learn addressing modes of ARM Instruction Set Architecture
This lab is intended for students who are not familiar with assembler, or have a very distant idea about it. If you have some idea of high-level languages such as Java, Basic C/C++ or Pascal then you will find assembly coding quite easy.
It is assumed that you have some knowledge about number representation in Hexa-decimal and binary. If you are not familiar with numbering systems, then you must go through before starting this lab.
1.2 The ARM Architecture
The ARM is a Reduced Instruction Set Computer (RISC) with a relatively simple implementation of a load/store architecture, i.e. an architecture where main memory (RAM) access is performed through dedicated load and store instructions, while all computation (sums, products, logical operations, etc.) is performed on values held in registers. ARM supports a small number of addressing modes with all load/store addresses being determined from registers and instruction fields only.
1.3 ARM Software Programming Model
ARM is a load store reducing instruction set computer architecture; it means the core cannot directly operate with the memory. All data operations must be done by registers with the information which is located in the memory. Performing the operation of data and storing the value back to the memory. ARM processor consists of 16 registers in which 13 register are data manipulation registers and other 3 registers are special purpose registers.
• R13 (Stack Pointer or SP): Holds address of the top of the stack • R14 (Link Register or LR): Holds return address from subroutine • R15 (Program Counter or PC): Hold address of the next instruction to be executed
1 Despite the name of a register, it’s the programmer who determines the usage for each general- purpose register. The main purpose of a register is to keep a number (variable). The size of the above registers is 32 bits.
Figure 1. ARM Registers
1.4 Assembly Language
An assembly language is a low-level programming language designed for a specific type of processor. It may be produced by compiling source code from a high-level programming language (such as C/C++) but can also be written from scratch. Assembly code can be converted to machine code using an assembler.
Since most compilers convert source code directly to machine code, software developers often create programs without using assembly language. However, in some cases, assembly code can be used to fine-tune a program. For example, a programmer may write a specific process in assembly language to make sure it functions as efficiently as possible.
2 Figure 2. Compiler and Assembler
1.5 Assembly Language Syntax
ARM assembler commonly uses following instruction format: Normally, the first operand is the destination of the operation. The number of operands in an instruction depends on the type of instruction, and the syntax format of the operand can also be different.
1.5.1 Label Label is an optional first field of an assembly statement. Labels are alphanumeric names used to define the starting location of a block of statements. Labels can be subsequently used in our program as an operand of some other instruction. When creating the executable file, the assembler will replace the label with the assigned value. Labels must be unique in the executable file because an identical label encountered by the Assembler will generate an error. ARM assembler has reserved first character of a line for the label field and it should be left blank for the instructions with no labels. In some compilers, labels can be optionally ended with colon (:) but it is not accepted by the ARM assembler as an end of the label field. Defining appropriate labels makes your program look more legible. Program location can be easily found and remembered using labels. It is easier to use certain functionality of your program in an entirely different code. i.e., your code can be used as a library program. You do not have to figure out memory addresses because it is a tedious task especially when the instruction size in your microcontroller is not fixed.
3 1.5.2 Opcode (Mnemonics)
Opcode is the second field in assembly language instruction. Assembly language consists of mnemonics, each corresponding to a machine instruction. Using a mnemonic, you can decide what operation you want to perform on the operands. Assembler must translate each mnemonic opcode into their binary equivalent.
1.5.3 Operands Next to the opcode is the operand field which might contain different number of operands. Some of the instructions in ARM Architecture will have no operand while other might have as many as four operands. The number of operands in an instruction depends on the type of instruction, and the syntax format of the operand can also be different. Normally, the first operand is the destination of the operation.
1.5.4 Comments Comments are messages intended only for human consumption. They have no effect on the translation process and indeed are not acted on by the ARM Assembler. The comment field of an assembly language instruction is also optional. A semicolon (;) signifies that the rest of the line is a comment and is to be ignored by the assembler.
1.6 Assembly Programming in Keil
In this section we learn to write a simple assembly language program with and without the startup file. This program can be used as a template for writing any assembly language program. An assembler is required to compile an assembly language program. Keil has an ARM assembler which can compile and build ARM assembly language programs. At first, create a New uVision Project and add an Assembly file in it.
Figure 3. Adding Assembly File
4 After adding an Assembly file, go to “Options for Target” and then in the “Debug” option select the Simulator.
Figure 4. Selecting Simulator
After that you can write your Assembly Program.
Assembly language is only a set of instructions for specific hardware resources. To drive the assembly and linking process, we need to use directives, which are interpreted by the assembler. Some commonly used directives are explained below:
1.7 Assembler Directives
Every program to be executed by a computer is a sequence of statements that can be read by the humans. An assembler must differentiate between the statements that will be converted into executable code and that instruct the assembler to perform some specific function. Assembler directives are commands to the assembler that direct the assembly process. Assembler directives are also called pseudo opcodes or pseudo-operations. They are executed by the assembler at assembly time not by the processor at run time. Machine code is not generated for assembler directives as they are not directly translated to machine language. Some tasks performed by these directives are: • Assign the program to certain areas in memory. • Define symbols. • Designate areas of memory for data storage. • Place tables or other fixed data in memory. • Allow references to other programs.
5 1.8 Area Directives AREA directive allows the programmer to specify the memory location to store code and data. Depending on the memory configuration of your device, code and data can reside in different areas of memory. A name must be specified for an area directive. There are several optional comma delimited attributes that can be used with AREA directive. Some of them are discussed below.
1.9 EXPORT and IMPORT Directives
A project may contain multiple source files. You may need to use a symbol in a source file that is defined in another source file. In order for a symbol to be found by a different program file, we need to declare that symbol name as a global variable. The EXPORT directive declares a symbol that can be used in different program files. GLOBAL is a synonym for EXPORT. The IMPORT directive provides the assembler with a name that is not defined in the current assembly.
1.10 Data Reservation Directives (DCB, DCD, DCW)
ARM assembler supports different data definition directives to insert constants in assembly code. This directive allows the programmer to enter fixed data into the program memory and treats that data as a permanent part of the program. Different variants of these directives are: 1. DCB (Define Constant Byte) to define constants of byte size. 2. DCW (Define Constant Word) allocates one or more halfwords of memory, aligned on two byte boundaries. 3. DCD (Define Constant Data) allocates one or more words of memory, aligned on four- byte boundaries.
1.11 END Directive
This directive causes the assembler to stop processing the current source file. Every assembly language source module must therefore finish with this directive.
6 1.12 Addressing Modes 1) Immediate Addressing mode The addressing mode in which the data operand is a part of the instruction itself is known as immediate addressing mode.
2) Register Addressing mode
By specifying the name of the register as an operand to the instruction, you may access the contents of that register. Consider the ARM Mov (move) instruction: MOV Destination, Source This instruction copies the data from the source operand to the destination operand. The 32 bit register are certainly valid operands for this instruction. In this addressing mode both source and destination operand will be registers. MOV R1, R2 ; valid operands In this command contents of register R2 will be copied in register R1.
MOV R2, [#123] ; invalid operands
3) Memory Addressing Modes
The ARM is a Load/Store Architecture and it does not support memory to memory data processing operations. Must move data values into registers before using them. This might sound inefficient, but in practice isn’t. Data Transfer instruction is used in Memory Addressing modes. • Memory to register or LOAD from memory to register • Register to memory or STORE from register to memory 1) LDR R2, [R1] This instruction will take the address in r1, and then load a 4-byte value from the memory pointed to it into register r2. Note: r1 is called the base register.
7 2) STR R2, [R1] This instruction will take the address in r1, and then store a 4 byte value from the register r2 to the memory pointed to by r1. Note: r1 is called the base register.
1.13 Pre-indexed addressing Mode
The effective address of the operand is the sum of the contents of a base register, Rn, and a signed offset. Example: LDR R0, [R1, #12] This instruction will take the pointer in R1, add 12 bytes to it, and then load the value from the memory pointed to by this calculated sum into register R0. STR R0, [R1, #-8] This instruction will take the pointer in R0, subtract 8 bytes from it, and then store the value from register R0 into the memory address pointed to by the calculated sum. R1 is called the base register. #constant is called the offset. Offset is generally used in accessing elements of array or structure: Base register points to beginning of array or structure. Base register is first updated, the updated address is used.
8 1.14 Post-indexed addressing Mode The effective address of the operand is the contents of Rn. The offset is then added to this address and the result is written back into Rn. Example: STR R0, [R1], #12
1.15 Load/Store Multiple Registers
In ARM Assembly, LDM/STM assembly instructions are used to load/store multiple registers. LDMxx → Load Multiple Registers STMxx → Store Multiple Registers STMFD/LDMFD → Load/Store Multiple Register Full Descending STMIA/LDMIA → Load/Store Multiple Increase After
9 Problems and Exercises Activity 01: Below is an Assembly Program which defines two 32-bit Arrays having five elements each. The program will add 5 into each element of Array 1 and stores it in Array 2.
Activity 02: Write an assembly program which defines two Arrays of 16 bits. Program will copy the contents of first Array into second Array. • Contents of both Arrays should be of 16 Bits. • Array-1 contents (9, 9, 9, 0, 1, 4, 3, 1, 2, 6) • Array-2 contents (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) • Load the Arrays into Registers of your choice • By using a third Register, load the contents of Array-1 and store it in Array-2 • Post-indexed Addressing mode will be used
10 Activity 03: Write an assembly program that will define two 32-bit Arrays of twenty values in each array. Program will copy the first Array into second Array using Multiple Load Store Instruction. • Copy the data by transferring 5 registers at a time. • Copy the data by transferring 10 values at a time.
Activity 04: What functions do the following commands perform?
1) LDR R1 , [ R2 , #16 ]
2) MOV R2 , [ #123 ]
3) STR R6 , [ R8 , #-4 ]
4) LDMIA R2! , { R6 – R11 }
11 Lab Exercise and Summary
Summary should cover Introduction, Procedure, Data Analysis and Evaluation.
12 Student’s Signature: Date:
13 Evaluation Criteria Method of Evaluation: Viva, File submitted on LMS.
Excellent Good Satisfactory Unsatisfactory Poor Marks
Obtained 10 9-7 6-4 3-1 0
Assignment All tasks Most tasks Some tasks Most tasks All tasks were completed were were were incomplete or correctly in completed completed incomplete or incorrect. given time correctly. correctly and incorrect and and have a Tasks could have an have no Didn’t complete be improved incomplete understanding perform tasks understanding further and understanding and have no have a understanding complete understanding
