BCA Syllabus: Microprocessor and Computer Architecture (BCA152)

Course Code: BCA152 | Credit Hours: 3 | Nature of Course: Theory + Lab | Year/Semester: II/I | Workload: Theory 3 hrs + Lab 3 hrs per week

Overview

Microprocessor and Computer Architecture takes BCA students underneath the operating system and programming languages they’ve been using so far, down to how a CPU actually executes an instruction. If Hardware Workshop (BCA106) taught you what components look like physically, BCA152 teaches you what happens electronically inside the processor itself — how registers hold data, how the ALU performs arithmetic, how an instruction cycle actually fetches and executes code, and how classic processors like the Intel 8085 and 8086 were built.

This course sits at Year II, Semester I, and it’s a theory-plus-lab subject: you’ll study computer architecture concepts in lecture, then put them into practice writing real 8085 assembly language programs — either on a physical microprocessor trainer kit or a software simulator. For students planning to specialize in embedded systems, computer engineering, or even just wanting to genuinely understand why software behaves the way it does at the hardware level, this is one of the most conceptually foundational courses in the BCA program.

What You’ll Learn

The course is organized into nine units, moving from basic microprocessor components through to advanced concepts like pipelining.

Unit 1: Introduction to Microprocessor (3 hrs)

Starts with the building blocks: registers, the Arithmetic Logic Unit (ALU), control and timing circuitry, and the three system buses (address, data, control). You’ll also look at how a microprocessor-based system is organized around these buses and where microprocessors show up in real applications.

Unit 2: 8085 Microprocessor (12 hrs)

The largest unit in the course, and the practical core of it. You’ll study the 8085’s functional block diagram, pin configuration, registers, flags, and its multiplexed address/data bus. This unit covers the instruction cycle and machine cycles (opcode fetch, memory read, memory write) with T-states, plus timing diagrams for key instructions like MOV, LDA, STA, and MVI. You’ll learn the full 8085 instruction set — data transfer (MOV, MVI, STA, LDA, LXI, LDAX, STAX, XCHG), arithmetic (ADD, ADI, ADC, SUB, SUI, SBB, INR, DCR, INX, DCX), logic (ANA, ANI, ORA, ORI, XRA, XRI, CMA, CMP), and branching (JMP, JNZ, JZ, JNC, JC) — and then apply it directly by writing assembly programs for 8-bit and 16-bit addition/subtraction, 8-bit multiplication and division, sequence programs, and array searching using loops and branching.

Unit 3: 8086 Microprocessor (4 hrs)

A shorter unit introducing the 8086’s logical block diagram, its Bus Interface Unit and Execution Unit, flags, the pipelining concept, and memory segmentation with segment registers — essentially the architectural upgrade from the 8-bit 8085 to the 16-bit 8086.

Unit 4: Basic Computer Architecture and Design (6 hrs)

Zooms out to general computer architecture: stored program organization, computer registers, common bus systems, instruction sets, and the timing/control behind the instruction cycle. Also covers micro-operations — arithmetic (addition, subtraction, increment, decrement), logic (AND, OR, NOT, NAND, NOR, XOR), and shift operations (logical, circular, arithmetic).

Unit 5: Microprogrammed Control Unit (5 hrs)

Compares hardwired versus microprogrammed control units, then covers control memory, address sequencing, micro-operations and micro-instructions, micro-instruction format, and both symbolic and binary microprograms (using FETCH as the working example).

Unit 6: Central Processing Unit (6 hrs)

Covers general register organization, stack organization, instruction formats (three-address, two-address, one-address, and zero-address instructions), and a comparison of RISC versus CISC architecture — a distinction that still matters today when comparing, say, ARM processors (RISC) against traditional x86 chips (CISC).

Unit 7: Computer Arithmetic (3 hrs)

Focuses on how a computer actually performs arithmetic at the bit level: addition and subtraction using signed magnitude data, addition and subtraction using signed 2’s complement data, and Booth’s multiplication algorithm — the standard technique for efficiently multiplying signed binary numbers.

Unit 8: Input and Output Organization and Memory Organization (5 hrs)

Covers peripheral devices, I/O interfaces and interface modules, the difference between isolated I/O and memory-mapped I/O, and interrupts. A key sub-topic is Direct Memory Access (DMA) — how data moves between memory and peripherals without constant CPU involvement. The memory half covers the memory hierarchy, primary memory (RAM and ROM) with address decoding examples, and secondary memory including magnetic disk structure and cache memory.

Unit 9: Pipelining (4 hrs)

The most advanced unit, covering the concept of pipelining and Flynn’s classification of computer architectures, pipeline speed-up ratio calculations, arithmetic pipelines (including floating-point addition/subtraction), instruction pipelining (the four-segment instruction pipeline model), and — importantly — data dependency, branch instruction handling, and pipeline hazards along with their solutions. This unit connects directly to how modern CPUs achieve high performance.

The Lab Component (48 Hours)

This course is explicitly Theory + Lab, and the lab work is where the architecture concepts become concrete. Expect to:

• Write assembly language programs using both a real 8085 microprocessor trainer kit and a software-based 8085 simulator
• Practice every instruction type and addressing mode in the 8085 instruction set
• Develop programs covering 8-bit and 16-bit addition/subtraction, 8-bit multiplication and division, logical operations, loops, bitwise manipulation, and branching
• Implement computer arithmetic algorithms using a high-level language, connecting the bit-level arithmetic theory from Unit 7 to actual code

Why This Course Matters

Microprocessor and Computer Architecture is often the course where BCA students first understand why certain code runs faster than other code, why 32-bit and 64-bit systems behave differently, and what’s actually happening during a “cache miss” or a “pipeline stall” — terms that get thrown around in tech interviews and systems-level job postings. It also lays groundwork for later courses in Operating Systems and Computer Networks, where concepts like interrupts, DMA, and memory hierarchy reappear in a software context.

Recommended Reference Books

• Gaonkar, R. S. (1998). Microprocessor Architecture, Programming, and Applications with the 8085
• Hall, D. V. (1986). Microprocessors and Interfacing: Programming and Hardware
• Mano, M. M. (1993). Computer System Architecture

Study Tips for BCA152

1. Learn the 8085 instruction set by category, not as one giant list. Grouping them as data transfer, arithmetic, logic, and branching (the way the syllabus itself organizes them) makes them far easier to recall in exams.
2. Draw timing diagrams by hand. Understanding T-states and machine cycles (opcode fetch, memory read, memory write) is much easier once you’ve traced through a MOV or STA instruction step by step yourself.
3. Practice Booth’s multiplication algorithm with actual binary numbers, not just the steps in the abstract — it’s a common exam question and easy to get wrong without hands-on practice.
4. RISC vs CISC is a favorite theory question. Be ready to explain it with real examples (ARM vs x86) rather than just a textbook definition.
5. Pipelining hazards are conceptually tricky — use small examples. Working through a 3-4 instruction pipeline by hand, spotting where a data dependency or branch causes a stall, builds intuition that’s hard to get from reading alone.
6. Use the simulator lab sessions to reinforce theory, not just complete assignments. Actually running an 8085 program you wrote makes register/flag behavior far more memorable than reading about it.

Frequently Asked Questions

What’s the difference between the 8085 and 8086 microprocessors covered in this course? The 8085 is an 8-bit microprocessor and forms the bulk of the course’s practical work; the 8086 is its 16-bit successor, introducing concepts like the Bus Interface Unit/Execution Unit split, basic pipelining, and memory segmentation.

Is this course only theory, or does it include practical work? It’s a Theory + Lab course, with 3 hours of lecture and 3 hours of lab work per week. The lab component involves writing real 8085 assembly programs on both trainer kits and simulators.

Why does the syllabus spend 12 hours on the 8085 specifically? It’s the largest single unit because the 8085 is used as the concrete, hands-on example for teaching microprocessor architecture — students learn general concepts like instruction cycles and addressing modes by directly programming this processor.

Do I need prior programming experience for this course? Basic familiarity with programming logic helps for the assembly language component, but the course introduces 8085 assembly from the ground up — no prior assembly language experience is assumed.

This page summarizes the official TU BCA syllabus for BCA152 (Microprocessor and Computer Architecture). For the complete, authoritative syllabus document, refer to your college’s official curriculum handbook.