Polling vs interrupt-driven execution in Embedded C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check the button state using polling.

Embedded C

while(1) {
    if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == [1]) {
        // Button pressed action
    }
}

Drag options to blanks, or click blank then click option'

A2

B0

C1

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of 1 for pressed state.

The button is considered pressed when the input pin reads 1 (high).

2fill in blank

medium

Complete the code to enable the interrupt for the button pin.

Embedded C

EXTI_InitTypeDef EXTI_InitStructure;

EXTI_InitStructure.EXTI_Line = EXTI_Line0;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_[1];
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);

Drag options to blanks, or click blank then click option'

AInterrupt

BPolling

CTimer

DDMA

Attempts:

3 left

💡 Hint

Common Mistakes

Using Polling mode instead of Interrupt mode.

The EXTI mode must be set to Interrupt to enable interrupt-driven execution.

3fill in blank

hard

Fix the error in the interrupt handler function name.

Embedded C

void [1](void) {
    if (EXTI_GetITStatus(EXTI_Line0) != RESET) {
        // Handle button press
        EXTI_ClearITPendingBit(EXTI_Line0);
    }
}

Drag options to blanks, or click blank then click option'

AEXTI_IRQHandler

BEXTI1_IRQHandler

CEXTI0_Handler

DEXTI0_IRQHandler

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong handler names like EXTI1_IRQHandler or EXTI0_Handler.

The correct interrupt handler name for EXTI line 0 is EXTI0_IRQHandler.

4fill in blank

hard

Fill both blanks to create a polling loop that waits for a button press and then toggles an LED.

Embedded C

while(1) {
    if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_[1]) == [2]) {
        GPIO_ToggleBits(GPIOC, GPIO_Pin_13);
    }
}

Drag options to blanks, or click blank then click option'

A0

B1

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong pin number or wrong pressed state value.

The button is connected to pin 0 and is pressed when the input reads 1.

5fill in blank

hard

Fill all three blanks to define an interrupt-driven setup: enable clock, configure GPIO pin as input, and enable NVIC interrupt.

Embedded C

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, [1]);

GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_[2];
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_Init(GPIOA, &GPIO_InitStructure);

NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = EXTI[3]_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);

Drag options to blanks, or click blank then click option'

AENABLE

B5

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using DISABLE instead of ENABLE, wrong pin number, or wrong IRQ channel.

Clock must be enabled (ENABLE), GPIO pin 0 is configured as input, and NVIC interrupt for EXTI0 is enabled.

Practice

1. Which statement best describes polling in embedded C programming?

easy

A. Polling repeatedly checks for an event in a loop.

B. Polling uses special functions to respond automatically to events.

C. Polling is more efficient than interrupt-driven execution.

D. Polling disables all hardware interrupts.

Solution

1. Step 1: Understand polling concept

   Polling means the program continuously checks if an event has happened by running a loop.

2. Step 2: Compare options

   Polling repeatedly checks for an event in a loop. correctly states polling as repeated checking. Options A, B, and C describe interrupts or incorrect facts.

3. Final Answer:

   Polling repeatedly checks for an event in a loop. -> Option A

4. Quick Check:

   Polling = repeated checking [OK]

Hint: Polling means checking repeatedly in a loop [OK]

Common Mistakes:

• Confusing polling with interrupts
• Thinking polling is automatic
• Assuming polling disables interrupts

2. Which of the following is the correct way to declare an interrupt service routine (ISR) in embedded C?

easy

A. void ISR() { /* code */ }

B. __interrupt void ISR() { /* code */ }

C. void interrupt ISR() { /* code */ }

D. interrupt void ISR() { /* code */ }

Solution

1. Step 1: Recall ISR declaration syntax

   In many embedded C compilers, the keyword __interrupt before the function declares it as an ISR.

2. Step 2: Check options

   __interrupt void ISR() { /* code */ } uses __interrupt correctly. Options A, B, and D use incorrect or incomplete syntax.

3. Final Answer:

   __interrupt void ISR() { /* code */ } -> Option B

4. Quick Check:

   ISR declaration = __interrupt keyword [OK]

Hint: ISR functions use __interrupt keyword before return type [OK]

Common Mistakes:

• Omitting __interrupt keyword
• Placing interrupt keyword after void
• Using plain void without interrupt

3. Consider this embedded C code snippet using polling:

while(1) {
  if (button_pressed()) {
    toggle_led();
  }
}

What happens when the button is pressed?

medium

A. The LED never toggles because interrupts are disabled.

B. The LED toggles only after the loop finishes.

C. The LED toggles immediately when the button is pressed.

D. The LED toggles only if an interrupt triggers.

Solution

1. Step 1: Analyze the polling loop

   The loop continuously checks if button_pressed() returns true, then calls toggle_led() immediately.

2. Step 2: Understand behavior on button press

   When the button is pressed, button_pressed() becomes true, so toggle_led() runs right away.

3. Final Answer:

   The LED toggles immediately when the button is pressed. -> Option C

4. Quick Check:

   Polling triggers action immediately on event [OK]

Hint: Polling checks and acts immediately inside the loop [OK]

Common Mistakes:

• Thinking toggle waits for loop end
• Confusing polling with interrupts
• Assuming interrupts are required

4. This code tries to use interrupts but has a bug:

void ISR() {
  toggle_led();
}

int main() {
  enable_interrupts();
  while(1) {}
}

What is the main problem?

medium

A. enable_interrupts() is called inside main loop.

B. The main loop should not be infinite.

C. toggle_led() cannot be called inside ISR.

D. ISR is missing the __interrupt keyword.

Solution

1. Step 1: Check ISR declaration

   The ISR function lacks the __interrupt keyword, so it won't be recognized as an interrupt handler.

2. Step 2: Review other code parts

   enable_interrupts() is correctly called once; toggle_led() can be called in ISR; infinite loop is normal in embedded main.

3. Final Answer:

   ISR is missing the __interrupt keyword. -> Option D

4. Quick Check:

   ISR needs __interrupt keyword [OK]

Hint: ISR must have __interrupt keyword to work [OK]

Common Mistakes:

• Forgetting __interrupt keyword
• Thinking infinite loop is wrong
• Assuming toggle_led() is invalid in ISR

5. You want to design a program that reads a sensor value only when it changes, without wasting CPU time checking constantly. Which method is best?

hard

A. Use an interrupt triggered by the sensor change.

B. Use polling to check sensor value in a tight loop.

C. Use a delay loop to check sensor every second.

D. Use a timer to poll sensor every millisecond.

Solution

1. Step 1: Understand the requirement

   The program should react only when the sensor changes and avoid wasting CPU time on constant checking.

2. Step 2: Compare methods

   Polling (options B, C, D) wastes CPU by checking repeatedly. Interrupt (Use an interrupt triggered by the sensor change.) triggers only on change, saving CPU.

3. Final Answer:

   Use an interrupt triggered by the sensor change. -> Option A

4. Quick Check:

   Interrupts save CPU by reacting only on events [OK]

Hint: Use interrupts to react only when events happen [OK]

Common Mistakes:

• Choosing polling for efficiency
• Using delays wastes CPU
• Confusing timer polling with interrupts