What is Firmware?
Explained from Scratch

You have heard “firmware update” on a TV, a router, or a game controller. This page starts from zero. No coding class required. If you can follow a recipe, you can follow firmware.

0. Three words first

Before the diagrams, lock in three words. Everything else on this page is just these three ideas wearing different clothes.

0.5 A washing machine, told like a story

Your school uniform is muddy. You put it in a washing machine and press Start. You do not stand there saying “now spin, now add water.” The machine already knows the steps:

1. Lock the door.
2. Fill with water.
3. Add a little soap time.
4. Spin slowly.
5. Drain.
6. Spin fast.
7. Beep. Done.

Those steps are not the metal drum. They are not the water. They are a list of orders saved inside a small chip in the machine. That list is firmware.

1. The Problem: Hardware Without a Brain

Imagine you are asked to build a traffic light for a small school crossing. The light needs to do this:

• 🟢 Green for 30 seconds (cars can go)
• 🟡 Yellow for 5 seconds (slow down!)
• 🔴 Red for 30 seconds (cars stop, children cross)

Attempt 1: Pure Hardware (No Brain)

Your first idea: "I will just wire it up with timers and relays!"

2. The Solution: Give Hardware a Brain

Instead of 3 timers and 3 relays, we replace everything with one tiny chip called a microcontroller (like Arduino, STM32, ESP32). This chip has:

• A small processor (the brain) — executes instructions one by one.
• Flash memory (permanent storage) — holds the firmware instructions even when power is off.
• GPIO pins (arms and legs) — electrical pins that can turn things ON and OFF.

3. Writing the Firmware (Step by Step)

Here is the recipe inside the traffic-light chip. Read it like English. You do not need to memorize the words.

• HIGH means “send electricity — light ON.”
• LOW means “stop electricity — light OFF.”
• delay(30000) means “wait 30,000 milliseconds,” which is 30 seconds.
• loop means “when you finish the list, start again at the top.”

// ═══════════════════════════════════════════
// FIRMWARE: Smart Traffic Light Controller
// Stored inside the chip's Flash memory
// ═══════════════════════════════════════════

// Step 1: Name the 3 GPIO pins
int RED_PIN   = 1;
int YELLOW_PIN = 2;
int GREEN_PIN  = 3;

// Step 2: When the chip powers on, do this ONCE
void setup() {
    // Tell the chip: these 3 pins will OUTPUT electricity
    pinMode(RED_PIN,    OUTPUT);
    pinMode(YELLOW_PIN, OUTPUT);
    pinMode(GREEN_PIN,  OUTPUT);
}

// Step 3: After setup, do this FOREVER (loop)
void loop() {

    // ── GREEN PHASE ──
    digitalWrite(GREEN_PIN, HIGH);   // Turn ON green
    delay(30000);                    // Wait 30 seconds
    digitalWrite(GREEN_PIN, LOW);    // Turn OFF green

    // ── YELLOW PHASE ──
    digitalWrite(YELLOW_PIN, HIGH);  // Turn ON yellow
    delay(5000);                     // Wait 5 seconds
    digitalWrite(YELLOW_PIN, LOW);   // Turn OFF yellow

    // ── RED PHASE ──
    digitalWrite(RED_PIN, HIGH);     // Turn ON red
    delay(30000);                    // Wait 30 seconds
    digitalWrite(RED_PIN, LOW);      // Turn OFF red

    // Loop back to GREEN automatically!
}

3.5 How the recipe gets into the chip

You do not open the chip with a screwdriver and drop letters inside. There are four simple steps. Think of translating a story into a secret code the chip can obey.

1. You write the recipe in a human-friendly language (often C, or Arduino’s simple C++). That is the traffic-light program above.
2. A compiler translates it into machine code: a long list of 0s and 1s. The chip cannot read English. It can only follow tiny electrical patterns.
3. A cable sends that list into the chip. On a school board this is a USB cable. In a factory it is a programmer jig that touches the chip before it is sealed in plastic.
4. The chip stores the list in flash memory. Unplug the cable. Turn the power off. The recipe is still there tomorrow.

3.6 What happens the moment you press power

Nothing magical. The chip wakes up and does the same four jobs every time:

1. Power arrives. The chip comes out of sleep. Its first job is not “be a traffic light.” Its first job is “start at instruction number 1.”
2. It reads one instruction from flash. Example: “make pin 3 an output.”
3. It does that instruction. Electricity on pin 3 is now allowed to drive the green lamp.
4. It moves to the next instruction and repeats. Green on. Wait. Green off. Yellow on. Wait. Forever, until power is removed.

That loop — read, do, next — is the whole life of firmware. A phone, a keyboard, and a washing machine are the same idea with longer recipes.

3.7 Three kinds of memory (school version)

So when someone says “the firmware is stored in flash,” they mean: the recipe sits in memory that remembers, and we can replace the recipe later if we find a bug.

4. Watch the Firmware Execute (Visual Simulation)

Below is a visual timeline showing exactly what happens inside the chip, clock cycle by clock cycle. The firmware reads each instruction from Flash memory and drives the GPIO pins accordingly:

5. Before vs After: Hardwired vs Firmware

6. Firmware is EVERYWHERE Around You

Now that you understand the concept, you will start seeing firmware everywhere:

6.5 What firmware is not

• Not the app. WhatsApp is software. The code that makes the phone’s power button wake the screen is firmware.
• Not the internet. A traffic light can run its recipe with no Wi-Fi. An update may travel over the internet, but the recipe itself lives in the chip.
• Not the operating system on a simple gadget. A keyboard has no Windows. It only has firmware.
• Not something you rewrite every second. You change it rarely: to fix a bug, add a feature, or patch a security hole.

7. Firmware vs Software: What is the Difference?

8. Frequently Asked Questions