Introduction to Assembly Language

Learning Objectives

By the end of this lesson, you should be able to:

• explain why assembly matters even when most firmware is written in C or C++;
• read the basic structure of an AVR assembly instruction;
• connect Arduino-style calls to registers, compiler output, and machine code;
• estimate delay-loop timing from clock cycles and identify when hardware timers are better;
• use disassembly as a practical debugging tool.

"I Already Know Arduino — Why Do I Need This?"

This is the most common question from engineering students. You bought an Arduino, you found a library online, you called digitalWrite(13, HIGH) and an LED blinked. It worked. So why go deeper?

Here is the honest answer: you did not make that LED blink. The library did. You copied the incantation.

There is nothing wrong with using libraries and Arduino for prototyping — professionals do it too. But right now you cannot answer these questions:

• Why does delay(1000) block everything else from running? What is it actually doing inside?
• Why does your servo jitter when you also try to read a sensor?
• Why does a for loop counting to 60000 take a different amount of time on different boards?
• Why does your I2C communication randomly fail, but only when you add one more variable?
• How does Serial.begin(9600) know what 9600 means, and what happens if you change it to 9601?

If you cannot answer these, you are not an embedded engineer yet. You are a sketch copier. The moment something goes wrong at the hardware level — and it always does in a real project — you will be stuck.

The Real Problem with Skipping Assembly

Consider this situation — common for every embedded engineer:

You are building a product. A motor must receive a pulse every exactly 1 millisecond. Even one missed pulse causes a fault. Your Arduino sketch uses delay(). This works on your desk. In the final product, you also need to read a temperature sensor over I2C, which sometimes takes 1.3 ms. Now your motor pulses are irregular. The product fails.

You search online: "Arduino delay not accurate." You find millis(). You rewrite the code. Still jitters. You find micros(). Still not right. You add volatile. Still fails. You spend three days.

An engineer who understands assembly understands immediately:

• delay() burns CPU cycles in a loop — nothing else runs
• millis() and micros() rely on Timer0 overflow interrupts — they have jitter equal to the longest function that runs with interrupts disabled
• The fix is a hardware timer interrupt with an ISR written in 4–5 instructions that executes in under 1 µs regardless of what the main loop is doing
• The I2C library disables interrupts during bit-banging — that is the root cause

That diagnosis takes 30 seconds when you understand what the hardware is doing. It takes three days when you are guessing.

What Arduino Actually Is

Arduino is not a language. It is not magic. It is:

When you call digitalWrite(13, HIGH), the Arduino library:

1. Looks up pin 13 in a constant table to find it is on Port B, bit 5
2. Reads the current DDRB register to check direction
3. Reads PORTB, sets bit 5, writes PORTB back
4. This takes about 50 clock cycles — 3.1 µs at 16 MHz

The direct register write PORTB |= (1 << PB5) takes 2 clock cycles — 125 ns. That is 25× faster.

For blinking an LED, this does not matter. For generating a precise PWM signal, driving a WS2812 LED strip (which requires bit-banging at 800 kHz with ±150 ns timing tolerance), or implementing a custom communication protocol, it is the difference between working and not working.

What You Will Be Able to Do After This Lesson

Every program you write — in C, Python, or Rust — eventually becomes assembly. Assembly is the language of the processor: one instruction, one operation, zero abstraction.

You do not need to write all your firmware in assembly. But you cannot be a good embedded engineer without understanding it. When a timing-critical interrupt needs to execute in exactly 4 cycles, or when a bug only manifests in the compiled output, assembly is where the answer lives.

What Is Assembly Language?

Assembly is a human-readable representation of machine code. Each assembly instruction corresponds to exactly one machine code instruction (one row of bits in Flash memory).

• LDI R16, 5 — Load Immediate: put the value 5 into register R16
• The assembler converts this to the binary pattern 1110 0000 0001 0101 (0xE015 in hex)
• The CPU reads 0xE015 from Flash and executes it

Anatomy of an Assembly Instruction

AVR Instruction Categories

The AVR instruction set has about 130 instructions grouped into categories:

Your First Assembly Program — Blink LED

This is the AVR assembly equivalent of the classic Arduino blink program. Let's trace every instruction:

In actual AVR assembly:

; Blink LED on PB5 — ATmega328P

.include "m328Pdef.inc"       ; Include register definitions

.cseg                          ; Code segment (goes into Flash)
.org 0x0000                    ; Start at reset vector

    ; --- Initialize Stack Pointer ---
    LDI   R16, HIGH(RAMEND)   ; RAMEND = 0x08FF for ATmega328P
    OUT   SPH, R16             ; Stack Pointer High byte
    LDI   R16, LOW(RAMEND)
    OUT   SPL, R16             ; Stack Pointer Low byte

    ; --- Set PB5 as output ---
    SBI   DDRB, 5              ; Set bit 5 of DDRB = output direction

loop:
    SBI   PORTB, 5             ; PB5 = HIGH (LED on)
    CALL  delay_500ms
    CBI   PORTB, 5             ; PB5 = LOW (LED off)
    CALL  delay_500ms
    RJMP  loop                 ; repeat forever

How a Delay Loop Works in Assembly

Software delay loops are a core embedded technique — you burn cycles counting down a register:

Assembly vs C — The Same Operation

Seeing C and assembly side by side is the fastest way to understand what the compiler does:

[!TIP] Use avr-objdump -d your_program.elf to see the disassembly of your compiled C code. This is invaluable for debugging timing issues or understanding what the compiler generated.

Addressing Modes

How an instruction finds its operand is called the addressing mode. Different modes give different power and flexibility:

The compiler automatically chooses the right addressing mode. When you see array[i] in C, it compiles to register indirect with post-increment. When you access struct.member, it uses displacement.

Reading a Disassembly Listing

When debugging, you will often look at disassembly output. Here is how to read it:

0000010a <main>:          ← function name and its address in Flash
 10a: cf 93              push r28      ← save caller's register
 10c: df 93              push r29
 10e: cd b7              in r28, 0x3d  ← read SPL into r28
 110: de b7              in r29, 0x3e  ← read SPH into r29
 112: e5 e0              ldi r30, 0x05 ← r30 = 5 (variable a)
 114: f3 e0              ldi r31, 0x03 ← r31 = 3 (variable b)
 116: ef 0f              add r30, r31  ← r30 = r30 + r31 = 8 (c = a+b)

Column 1: Flash address (hex). Column 2: Machine code bytes. Column 3+: Assembly mnemonic.

Worked Example: Counting a Tiny Delay

A timing loop is only useful when you can count it:

    ldi  r18, 200      ; 1 cycle
delay:
    dec  r18           ; 1 cycle
    brne delay         ; 2 cycles when taken, 1 cycle when not taken

For 200 iterations:

cycles = 1 + (199 x (1 + 2)) + (1 + 1)
cycles = 1 + 597 + 2 = 600 cycles

At F_CPU = 16 MHz, one cycle is 1 / 16,000,000 = 62.5 ns.

time = 600 x 62.5 ns = 37.5 us

This is why assembly still matters: you can look at a loop, count cycles, and know whether it can meet a real timing budget. For long waits or concurrent work, prefer a hardware timer interrupt instead of burning CPU cycles in a loop.

Common Mistakes

Summary

Further Reading

• Microchip, AVR Instruction Set Manual, for instruction syntax, flags, and cycle counts.
• Microchip, ATmega328P Datasheet, for I/O register names, timers, interrupts, and memory map.
• avr-libc documentation, especially startup code, register definitions, and interrupt support.
• GNU Binutils documentation for avr-as and avr-objdump.

Mind Map

Next: CISC vs RISC — 8051 vs AVR →