Coursify

Microprocessor

Assembly Language Programming

1.25 hours

Learning Goals

  • Understand assembly language syntax: recognizing OPCODE (instruction mnemonic like MOV, ADD, JNC) and OPERAND (specifying data or addresses) structure, distinguishing between instruction types by operand requirements, and applying consistent formatting for code readability
  • Master instruction syntax variations: MOV instruction with multiple addressing modes (MOV A, R0 for register mode, MOV A, #35H for immediate, MOV A, 0FH for direct addressing), recognizing addressing mode indicators in syntax, and selecting appropriate syntax for program requirements
  • Define data types and constants: declaring byte and word data types, specifying 8-bit values (0-255) and 16-bit values (0-65535), utilizing program memory for constant tables, and managing data placement in separate program vs data memory spaces
  • Implement subroutine structure: organizing code into modular functions with entry/exit conventions, managing subroutine parameters through registers and stack, implementing local variable allocation, and maintaining call stack discipline
  • Apply program organization: structuring assembly programs with initialization code, main program loop, and interrupt handlers, utilizing include files for macro definitions and reusable code libraries, and maintaining separation of concerns for maintainability
  • Understand rotate and shift operations: RRC (Rotate Right through Carry) instruction behavior rotating 9-bit value (accumulator + carry flag) right with wraparound, affecting carry flag with rotated-out bit, and utilizing for bit manipulation and multiplication/division by 2
  • Trace assembly program execution: executing instruction sequences showing register state changes, following subroutine calls with stack manipulation, and predicting program outcomes before machine execution
  • Translate assembly to machine code: recognizing that assembler translates assembly syntax to binary machine code automatically, understanding assembler's role in generating executable programs, and recognizing assembler directives for code generation control

Assembly language serves as the low-level bridge between human-readable logic and the binary reality of microprocessors. Unlike high-level languages, every assembly instruction corresponds directly to a specific machine operation . In the context of microprocessors like the 8051, understanding the Instruction Syntax is the first step toward mastering hardware control.

An assembly instruction consists of two primary components:

  1. OPCODE (Operation Code): The mnemonic that identifies the action to be performed (e.g., MOV, ADD, SUBB).
  2. OPERAND: The data or the location of data (registers, memory addresses, or constants) that the opcode acts upon.

The number of operands varies by instruction. Some require two (e.g., MOV A, R0), some require one (e.g., INC A), and others require none (e.g., RET) .

Footnotes

  1. Introduction to Assembly - Overview of 8051 instruction sets and syntax. ↩

  2. The 8051 Assembly Language - Detailed guide on addressing modes, subroutines, and stack operations. ↩

Introduction to 8051 Assembly Programming

The operand is a constant value specified directly in the instruction using the # symbol.

Example: MOV A, #35H

  • Action: Loads the hexadecimal value 351635_{16} (53 decimal) directly into the Accumulator.
  • Use Case: Initializing registers with known constants .

Footnotes

  1. Introduction to Assembly - Overview of 8051 instruction sets and syntax. ↩

Assembly Data Types and Ranges

Comparison of 8-bit (Byte) vs 16-bit (Word) capacity

Assembler Directives vs. Instructions

Instructions (like MOV) are converted into machine code for the CPU to execute. Directives (like ORG, DB, or END) are commands for the Assembler itself to organize memory or define constants; they do not result in executable CPU opcodes .

Footnotes

  1. Assembler Directives Explained - Distinguishing between CPU instructions and assembler commands. ↩

Implementing Subroutine Structure

  1. 1
    Step 1

    Define the subroutine using a label. The main program transfers control using LCALL (Long Call) or ACALL (Absolute Call). This automatically pushes the current Program Counter (PC) onto the stack .

    Footnotes

    1. The 8051 Assembly Language - Detailed guide on addressing modes, subroutines, and stack operations. ↩

  2. 2
    Step 2

    Load registers (R0-R7) or specific memory locations with the data the subroutine needs to process before the call.

  3. 3
    Step 3

    The subroutine performs its logic. If local variables are needed, they are typically assigned to unused registers or specific RAM addresses, maintaining stack discipline to avoid overwriting the return address.

  4. 4
    Step 4

    The subroutine must end with the RET instruction. This pops the return address from the stack back into the PC, allowing the program to resume immediately after the original call .

    Footnotes

    1. 8051 Instruction Set - Complete reference for opcodes like MOV, ACALL, and RET. ↩

Bit Manipulation: Rotate Right through Carry (RRC)

The RRC A instruction is a powerful tool for bitwise operations and arithmetic. It treats the 8-bit Accumulator and the 1-bit Carry Flag (C) as a single 9-bit circular buffer .

How RRC Works:

  • Each bit in the Accumulator shifts one position to the right.
  • The bit originally in the Carry Flag moves into the Most Significant Bit (D7) of the Accumulator.
  • The bit originally in the Least Significant Bit (D0) of the Accumulator moves into the Carry Flag.

This operation is frequently used for:

  • Division by 2: A right shift effectively divides an unsigned integer by 2.
  • Serial Data Processing: Shifting bits out one by one into the Carry flag for transmission .

Footnotes

  1. 8051 Microcontroller Assembly Guide - Explanation of logical operations and bit manipulation like RRC. ↩ ↩2

Stack Discipline

Always ensure that every PUSH in a subroutine is balanced by a POP before the RET instruction. Failing to do so will cause the CPU to pop the wrong value into the Program Counter, leading to a system crash .

Footnotes

  1. The 8051 Assembly Language - Detailed guide on addressing modes, subroutines, and stack operations. ↩

Program Organization and Translation

Knowledge Check

Question 1 of 4
Q1Single choice

Which addressing mode is used in the instruction 'MOV A, #45H'?

Previous

Next