ADC interrupt-driven reading in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this ADC interrupt handler?

Consider the following ADC interrupt handler code snippet. What value will adc_value hold after the interrupt?

Embedded C

volatile uint16_t adc_value = 0;

void ADC_IRQHandler(void) {
    if (ADC_GetITStatus(ADC1, ADC_IT_EOC)) {
        adc_value = ADC_GetConversionValue(ADC1);
        ADC_ClearITPendingBit(ADC1, ADC_IT_EOC);
    }
}

// Assume ADC_GetConversionValue(ADC1) returns 1234 when called.

A adc_value will be uninitialized garbage

B adc_value will be 4095

C adc_value will be 0

D adc_value will be 1234

💡 Hint

Think about what happens inside the interrupt when the end of conversion flag is set.

The interrupt handler checks if the ADC end of conversion (EOC) flag is set. If yes, it reads the conversion value (which is 1234) and stores it in adc_value. Then it clears the interrupt flag. So adc_value becomes 1234.

🧠 Conceptual

intermediate

Which statement best describes ADC interrupt-driven reading?

Choose the best description of how ADC interrupt-driven reading works in embedded systems.

A The ADC triggers an interrupt when conversion completes, allowing the CPU to handle the result asynchronously.

B The CPU continuously polls the ADC status register to check if conversion is done.

C The ADC conversion result is stored automatically in a global variable without CPU intervention.

D The ADC conversion starts only when the CPU writes the result to memory.

💡 Hint

Think about how interrupts help the CPU avoid waiting actively.

In interrupt-driven ADC reading, the ADC hardware triggers an interrupt when the conversion finishes. This lets the CPU do other tasks and respond only when data is ready.

🔧 Debug

advanced

Why does this ADC interrupt handler fail to update the value?

Examine the code below. The adc_value variable never updates after ADC conversions. What is the likely cause?

Embedded C

uint16_t adc_value;

void ADC_IRQHandler(void) {
    if (ADC_GetITStatus(ADC1, ADC_IT_EOC)) {
        uint16_t value = ADC_GetConversionValue(ADC1);
        ADC_ClearITPendingBit(ADC1, ADC_IT_EOC);
    }
}

// adc_value is expected to hold the latest ADC reading.

A The ADC conversion value function returns zero always.

B The interrupt flag is not cleared, so the handler never runs.

C <code>adc_value</code> is never assigned inside the interrupt handler.

D The variable <code>adc_value</code> is declared as volatile, causing optimization issues.

💡 Hint

Check if the variable that stores the ADC result is updated.

The handler reads the ADC value into a local variable value but never assigns it to the global adc_value. So adc_value remains unchanged.

📝 Syntax

advanced

Which option correctly enables ADC interrupt in this code?

Given the following code snippet, which option correctly enables the ADC interrupt?

Embedded C

void ADC_Config(void) {
    ADC_InitTypeDef ADC_InitStructure;
    // ADC initialization code here

    // Enable ADC interrupt
    // ???
}

A ADC_ITConfig(ADC1, ADC_IT_EOC, ENABLE);

B ADC_ITConfig(ADC1, ADC_IT_OVR, DISABLE);

C ADC_ITConfig(ADC1, ADC_IT_EOC);

D ADC_ITConfig(ADC1, ENABLE, ADC_IT_EOC);

💡 Hint

Check the correct order and parameters for enabling ADC interrupts.

The function ADC_ITConfig takes the ADC peripheral, the interrupt type, and ENABLE or DISABLE. Option A uses the correct order and parameters.

🚀 Application

expert

How many ADC readings are stored after this interrupt-driven sequence?

Consider this code that uses an interrupt to read ADC values into a buffer of size 4. How many valid readings will adc_buffer contain after 6 ADC conversions?

Embedded C

volatile uint16_t adc_buffer[4];
volatile uint8_t index = 0;

void ADC_IRQHandler(void) {
    if (ADC_GetITStatus(ADC1, ADC_IT_EOC)) {
        adc_buffer[index++] = ADC_GetConversionValue(ADC1);
        if (index >= 4) {
            index = 0;
        }
        ADC_ClearITPendingBit(ADC1, ADC_IT_EOC);
    }
}

// Assume 6 ADC conversions complete, each triggering the interrupt.

A 6 readings, all stored without overwrite

B 4 readings, the buffer overwrites oldest values after 4

C 2 readings, because index resets after 4

D 0 readings, buffer is never updated

💡 Hint

Think about how the index variable cycles through the buffer size.

The buffer size is 4. After 4 readings, the index resets to 0, so the next 2 readings overwrite the first 2. The buffer always holds the last 4 readings.

Practice

1. What is the main advantage of using ADC interrupt-driven reading in embedded C?

easy

A. The CPU can perform other tasks while ADC conversion happens

B. It makes the ADC conversion faster

C. It disables other interrupts during ADC conversion

D. It reduces the ADC resolution automatically

Solution

1. Step 1: Understand ADC interrupt-driven reading

   ADC interrupt-driven reading allows the CPU to continue other work while waiting for ADC conversion to complete.

2. Step 2: Identify the main benefit

   This method improves efficiency by not blocking the CPU during ADC conversion.

3. Final Answer:

   The CPU can perform other tasks while ADC conversion happens -> Option A

4. Quick Check:

   Interrupt-driven ADC = CPU multitasking [OK]

Hint: Interrupts let CPU work during ADC conversion [OK]

Common Mistakes:

• Thinking ADC conversion speed increases
• Assuming interrupts disable other interrupts
• Believing ADC resolution changes automatically

2. Which of the following is the correct way to declare a variable shared between main code and ADC interrupt handler?

easy

A. const int adc_value;

B. int adc_value;

C. static int adc_value;

D. volatile int adc_value;

Solution

1. Step 1: Identify variable sharing between ISR and main code

   Variables shared between interrupt handlers and main code must be declared volatile to prevent compiler optimization issues.

2. Step 2: Choose the correct declaration

   Using 'volatile int adc_value;' ensures the variable is read fresh each time and not cached.

3. Final Answer:

   volatile int adc_value; -> Option D

4. Quick Check:

   Shared variable = volatile [OK]

Hint: Use volatile for variables shared with interrupts [OK]

Common Mistakes:

• Omitting volatile causing stale reads
• Using const which prevents modification
• Using static which limits scope but not volatility

3. Given this ADC interrupt handler code snippet, what will be the value of adc_result after the interrupt?

volatile int adc_result = 0;
void ADC_ISR(void) {
    adc_result = ADC_Read();
    ADC_ClearInterruptFlag();
}

medium

A. The previous ADC conversion value

B. Zero, because adc_result is volatile

C. The latest ADC conversion value

D. An undefined value due to missing initialization

Solution

1. Step 1: Analyze the interrupt handler code

   The handler reads the ADC value using ADC_Read() and stores it in adc_result, then clears the interrupt flag.

2. Step 2: Understand the effect on adc_result

   After the interrupt, adc_result holds the latest ADC conversion value read by ADC_Read().

3. Final Answer:

   The latest ADC conversion value -> Option C

4. Quick Check:

   ISR updates adc_result with new ADC value [OK]

Hint: ISR updates adc_result with fresh ADC reading [OK]

Common Mistakes:

• Confusing volatile with zero initialization
• Assuming adc_result remains unchanged
• Ignoring ADC_ClearInterruptFlag() role

4. Identify the error in this ADC interrupt-driven code snippet:

volatile int adc_val;
void ADC_ISR(void) {
    adc_val = ADC_Read();
    // Missing ADC_ClearInterruptFlag();
}

medium

A. adc_val should not be volatile

B. ADC_ClearInterruptFlag() is missing, causing repeated interrupts

C. ADC_Read() should not be called inside ISR

D. ISR function must return a value

Solution

1. Step 1: Review the ISR code

   The ISR reads ADC value but does not clear the interrupt flag.

2. Step 2: Understand interrupt flag importance

   Not clearing the interrupt flag causes the interrupt to trigger repeatedly, leading to an infinite loop of interrupts.

3. Final Answer:

   ADC_ClearInterruptFlag() is missing, causing repeated interrupts -> Option B

4. Quick Check:

   Clear interrupt flag to stop repeated ISR calls [OK]

Hint: Always clear interrupt flag inside ISR [OK]

Common Mistakes:

• Forgetting to clear interrupt flag
• Thinking volatile is incorrect here
• Expecting ISR to return a value

5. You want to implement ADC interrupt-driven reading that updates a global variable only when the ADC value exceeds 500. Which code snippet correctly implements this logic inside the ISR?

hard

A. void ADC_ISR(void) {
int val = ADC_Read();
if (val > 500) {
adc_value = val;
}
ADC_ClearInterruptFlag();
}

B. void ADC_ISR(void) {
if (adc_value > 500) {
adc_value = ADC_Read();
}
ADC_ClearInterruptFlag();
}

C. void ADC_ISR(void) {
adc_value = ADC_Read();
if (adc_value > 500) {
ADC_ClearInterruptFlag();
}
}

D. void ADC_ISR(void) {
ADC_ClearInterruptFlag();
int val = ADC_Read();
if (val > 500) {
adc_value = val;
}
}

Solution

1. Step 1: Check ADC reading and condition

   void ADC_ISR(void) {
       int val = ADC_Read();
       if (val > 500) {
           adc_value = val;
       }
       ADC_ClearInterruptFlag();
   }

   reads ADC value into a local variable, then updates global adc_value only if val > 500.

2. Step 2: Verify interrupt flag clearing

   void ADC_ISR(void) {
       int val = ADC_Read();
       if (val > 500) {
           adc_value = val;
       }
       ADC_ClearInterruptFlag();
   }

   clears the interrupt flag after processing, which is correct to prevent repeated interrupts.

3. Final Answer:

   Updates adc_value only if ADC reading exceeds 500 and clears interrupt flag -> Option A

4. Quick Check:

   Read ADC, check >500, update, clear flag [OK]

Hint: Read ADC first, then check condition, clear flag last [OK]

Common Mistakes:

• Clearing interrupt flag before reading ADC
• Checking old adc_value instead of new ADC reading
• Not clearing interrupt flag causing repeated interrupts