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.