ADC interrupt-driven reading in Embedded C - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to enable the ADC.

Embedded C

ADC->CR2 |= [1];

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

AADC_CR2_CONT

BADC_CR2_ADON

CADC_CR2_DMA

DADC_CR2_EOCS

Attempts:

3 left

💡 Hint

Common Mistakes

Using ADC_CR2_CONT which enables continuous mode but not interrupt.

Using ADC_CR2_DMA which enables DMA, not interrupt.

Using ADC_CR2_EOCS which configures end of conversion selection.

The ADC_CR2_ADON bit enables the ADC.

2fill in blank

medium

Complete the code to start the ADC conversion.

Embedded C

ADC->CR2 |= [1];

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

AADC_CR2_SWSTART

BADC_CR2_ADON

CADC_CR2_EXTTRIG

DADC_CR2_DMA

Attempts:

3 left

💡 Hint

Common Mistakes

Using ADC_CR2_ADON which only enables ADC but does not start conversion.

Using ADC_CR2_EXTTRIG which is for external trigger, not software start.

Using ADC_CR2_DMA which enables DMA, unrelated to start.

ADC_CR2_SWSTART starts the ADC conversion by software.

3fill in blank

hard

Fix the error in the interrupt handler to clear the ADC interrupt flag.

Embedded C

void ADC_IRQHandler(void) {
    if (ADC->SR & [1]) {
        uint16_t value = ADC->DR;
        // process value
        ADC->SR &= ~ADC_SR_EOC;
    }
}

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

AADC_SR_EOC

BADC_SR_STRT

CADC_SR_AWD

DADC_SR_OVR

Attempts:

3 left

💡 Hint

Common Mistakes

Checking ADC_SR_OVR which is overrun flag, not conversion complete.

Checking ADC_SR_AWD which is analog watchdog flag.

Checking ADC_SR_STRT which is start flag, not end.

ADC_SR_EOC is the end of conversion flag that must be checked and cleared.

4fill in blank

hard

Fill both blanks to configure the NVIC for ADC interrupt with priority 1.

Embedded C

NVIC_SetPriority([1], 1);
NVIC_EnableIRQ([2]);

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

AADC_IRQn

BTIM2_IRQn

CUSART1_IRQn

DEXTI0_IRQn

Attempts:

3 left

💡 Hint

Common Mistakes

Using unrelated IRQ numbers like TIM2_IRQn or USART1_IRQn.

Mismatching IRQ numbers between priority and enable calls.

ADC_IRQn is the interrupt number for ADC; both priority and enable use it.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that stores ADC values for channels with readings above 1000.

Embedded C

adc_values = { [1]: [2] for [3] in channels if readings[[3]] > 1000 }

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

Achannel

Breadings[channel]

D{

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the opening brace.

Using wrong variable names for keys or values.

Incorrect comprehension syntax.

The dictionary comprehension syntax requires braces, key:value pairs, and iteration variable.

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