why interrupts are better than polling?

Interrupts don’t just save CPU time — they can dramatically extend battery life in embedded systems.

Consider a simple polling loop:

while(1)
{
    if(UART_data_available())
        read_uart();
}

Even when no data arrives, the CPU keeps checking continuously.
So the microcontroller stays in active mode, consuming power.

With interrupts, the CPU can sleep and wake only when an event occurs.
In many microcontrollers:
• Active current → few mA
• Sleep current → few µA
That difference is why many battery-powered IoT devices run for months or even years.
Interrupts are not just about saving CPU cycles —
they are also essential for low-power embedded design.
Do you prefer polling or interrupts in your designs?

#EmbeddedSystems #Microcontrollers #Firmware #IoT #LowPowerDesign
#ARM #TechLearning

#whyseries 

LinkedIn


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 Are Interrupts Better Than Polling?

Image
In embedded systems, peripherals constantly generate events. A UART receives a byte. A timer expires. A GPIO pin changes state. An ADC conversion completes. The processor needs to respond to these events. There are two common approaches: Polling Interrupts At first, polling looks simple. But interrupts usually provide a more efficient way for the CPU to respond to asynchronous events. What Is Polling? In polling, the CPU repeatedly checks whether an event has occurred. For example: while (1) { if (UART_RX_READY) { read_uart_data(); } } The processor keeps asking the UART: "Did data arrive?" If no data has arrived, the CPU checks again. And again. And again. Imagine UART data arrives only once every 100 ms. During those 100 ms, the CPU may check the same status flag thousands of times even though nothing has happened. That CPU time could have been used for something else. What Changes With Interrupts? With interrupt...
Read more

Why Does the Stack Usually Grow Downward?

Image
When debugging nested function calls, you may notice the Stack Pointer moving toward lower memory addresses as the call depth increases. For example: SP = 0x20001000 PUSH {R4} SP = 0x20000FFC But why does this happen? Is a downward-growing stack inherently better, or is it simply an architectural convention? 1. The Stack Does Not Have to Grow Downward A processor can support either: Descending stack: SP decreases as data is pushed. or: Ascending stack: SP increases as data is pushed. Both approaches can work efficiently. So the real question is: Why did descending stacks become so common? 2. It Fits Traditional Memory Layouts Well A simplified memory layout often looks like this: High Address +------------------+ | Stack | | ↓ | | | | Free RAM | | | | ↑ | | Heap | +------------------+ Low Address The stack can begin near the upper end of available memory and grow toward lower addr...
Read more