What Happens Inside a Microcontroller in the First Few Microseconds After Power-On?

When power is applied to a microcontroller, the CPU does not immediately start executing your program.
Instead, a sequence of hardware-controlled steps occurs to prepare the system for execution.
Understanding this startup process helps explain how embedded systems begin running firmware.
1. Power Is Applied
When the device receives power:
Internal circuits begin initializing.
The microcontroller enters a reset state to ensure safe startup.
During this stage, the CPU is held in reset and cannot execute instructions yet.
2. Internal Oscillator Starts
Most microcontrollers start using an internal RC oscillator.
The reason is simple:
It starts very quickly
It does not require external components
It allows the processor to begin operating immediately
This oscillator provides the initial system clock.
3. Reset Controller Holds the CPU
Even though the clock has started, the CPU is still held in reset by the reset controller.
This ensures:
Power is stable
Clock is stable
Internal hardware is ready
Only after these conditions are satisfied will the processor be allowed to run.
4. CPU Released From Reset
Once the system becomes stable, the reset signal is released.
At this moment, the CPU begins executing instructions.
But where does it start executing?
5. Vector Table Is Read
In most modern microcontrollers (such as ARM Cortex-M), the CPU reads a structure called the vector table, which is stored in Flash memory.
The vector table contains important startup information.
The first two entries are:
Address
Description
0x00000000
Initial Stack Pointer value
0x00000004
Reset Handler address
6. Stack Pointer and Program Counter Are Loaded
The processor automatically loads:

SP = *(0x00000000)
PC = *(0x00000004)
The Stack Pointer (SP) is initialized.
The Program Counter (PC) is loaded with the address of the Reset Handler.
7. Reset Handler Executes
The CPU now jumps to the Reset Handler, which is the first piece of firmware executed.
This startup code typically performs tasks such as:
Initializing memory
Copying initialized data to RAM
Clearing uninitialized variables
Configuring system clocks
After these steps are completed, the program eventually reaches the main() function.
Summary
The startup process of a microcontroller follows this sequence:

Power ON
   ↓
Internal oscillator starts
   ↓
CPU held in reset
   ↓
Reset released
   ↓
Vector table read
   ↓
Stack Pointer loaded
   ↓
Program Counter loaded
   ↓
Reset Handler executes
Only after this sequence does the microcontroller begin running the main application.

#arm
#MCUS
#Microcontrollers
#embeddedsystems
#embeddedsystemfundamentals 

Comments

Post a Comment

Thanks for reading through the Embedded Systems World.
Feel free to ask questions or share your thoughts on the topic.

Popular posts from this blog

Why Do Microcontrollers Start with an Internal Oscillator?

Why Does a Microcontroller Start With an Internal Oscillator? When a microcontroller powers on, it needs one thing before it can execute even its first instruction: A clock. Most microcontrollers initially run from an internal oscillator. But if an external crystal is more accurate, why doesn't the microcontroller simply start with it? The answer comes down to startup speed, reliability, and initialization sequence. 1️⃣ Fast Startup Internal RC oscillators can become usable very quickly. External crystals need additional time for their oscillations to build and stabilize. Instead of waiting, the MCU can start executing firmware using its internal clock. Power ON → Internal Oscillator → CPU Starts Executing Meanwhile, the external clock source can be initialized and allowed to stabilize. 2️⃣ Guaranteed Availability The internal oscillator is built into the microcontroller. An external crystal depends on components outside the MCU, such as: • Crystal or resonator • Load capacitors • ...
Read more

Why RISC is ideal for embedded systems

Image
While revisiting CPU architecture concepts, I summarized why many microcontrollers use RISC architectures. 🔹 1. Predictable execution timing RISC processors typically use fixed-length instructions, making decoding simpler and execution timing more predictable — important for embedded and real-time systems. Example: ADD R1, R2, R3 SUB R4, R5, R6 🔹 2. Register-based operations RISC follows a Load–Store architecture. ALU operations use registers, while memory is accessed only through LOAD and STORE instructions. Example: LOAD R1, [100] LOAD R2, [104] ADD R3, R1, R2 STORE R3, [108] 🔹 3. Simpler hardware design Because instructions are simple and uniform, the control logic and instruction decoding hardware are simpler, which also helps reduce silicon die size. Example: MOV R1, R2 ADD R3, R1, R4 Conceptually: Register → ALU → Register 🔹 4. Efficient pipelining Fixed instruction formats allow CPUs to pipeline instructions efficiently, improving throughput. Example s...
Read more