Subroutine and Look-up Table

CSC-167 · Semester II · Microprocessor

intermediate30 minAvailable

CALL pushes the return address; RET pops it back.

Execution trace

MAIN: MVI A, 05H — set up operand
CALL SQUARE — push return address 0x2010
SQUARE: MOV B, A ; LOOP: ADD A — A = A*2 twice
compute A*A by repeated addition → 25
RET — pop return address back into PC
MAIN resumes at 0x2010 — A holds 25

Stack pointer: 0x3FFF

(empty)

Look-up table (XLAT-style)

0→11→42→93→164→255→366→497→648→819→100

With XLAT, loading the index into A and pointing HL at the table base fetches the answer in one instruction — much faster than computing squares.

Lab brief

Objective

Build a delay subroutine, call it from a main program, and use a look-up table to convert a digit into its seven-segment pattern.

Theory & concepts

A subroutine is a reusable block reached by CALL and exited by RET; the return address is stored on the stack. A look-up table replaces computation with a memory read: index into a table by adding the index to the table base address. Seven-segment decoding is the classic example.

Rendering diagram…

Subroutine call, look-up table and stack

; Main program: display digit 5 on a common-cathode display.
; Seven-segment patterns stored at table base 8000H.
        LXI SP, 9000H   ; set stack before any CALL
        MVI B, 05H      ; digit to display
        CALL  LOOKUP    ; B -> A = segment pattern
        OUT 01H         ; send pattern to the display port
        CALL  DELAY     ; keep it visible
        HLT

LOOKUP: LXI H, 8000H   ; base of the pattern table
        MOV A, B       ; digit index
        ADD L          ; index + low address byte
        MOV L, A
        JNC  GET
        INR H          ; handle carry into the high byte
GET:    MOV A, M       ; A = pattern for the digit
        RET

DELAY:  MVI C, FFH     ; outer count
AGAIN:  DCR C
        JNZ AGAIN
        RET

TABLE:  DB 3FH,06H,5BH,4FH,66H,6DH   ; patterns 0-5
        DB 7DH,07H,7FH,6FH            ; patterns 6-9

Stack first, call later

CALL writes the return address to the stack. If SP is not initialized (LXI SP) at the start of the program, the return address lands in unknown memory and RET jumps to garbage.

Prerequisites

Lesson: Subroutines, the stack and look-up tables
Lesson: 8085 instruction set at a glance

Instructions

1Set SP to 9000H with LXI SP before any subroutine call.
2Place the seven-segment patterns in memory starting at 8000H.
3Run the main program with B = 5 and confirm the output on the display port is 6DH.
4Change B to 0, 2 and 9 and verify 3FH, 5BH and 6FH.
5Single-step through CALL and RET and watch the return address move through the stack.

Tasks

Verify all ten digits
Confirm the pattern for each digit 0-9 against the table.
Trace the stack
Record SP before CALL, during the subroutine, and after RET.
Add a second subroutine
Write a longer delay and call it twice; confirm nesting works.

Self-check

All ten look-up results match the seven-segment patterns.
The return address is correctly saved and restored through the stack.
The student can trace CALL and RET with the stack contents.

Environment

8085 assemblerstack viewmemory editorsingle-step execution