15 Microcontroller Interview Questions and Answers

Microcontrollers are integral components in a wide array of modern electronic devices, from household appliances to complex industrial systems. These compact integrated circuits are designed to perform specific control functions, making them essential for embedded systems. Their versatility and efficiency have made them a cornerstone in the fields of automation, robotics, and IoT (Internet of Things).

This article provides a curated selection of interview questions and answers focused on microcontrollers. By reviewing these questions, you will gain a deeper understanding of key concepts and practical applications, enhancing your ability to demonstrate your expertise in technical interviews.

Microcontroller Interview Questions and Answers

1. Describe the difference between polling and interrupt-driven I/O.

Polling involves the microcontroller continuously checking the status of an I/O device in a loop until the device is ready, which can be inefficient as it consumes CPU time. Interrupt-driven I/O, however, allows the microcontroller to perform other tasks and only respond when an interrupt signal is received, making it more efficient.

2. Explain the function of PWM (Pulse Width Modulation) and provide a use case.

PWM (Pulse Width Modulation) controls the power supplied to devices by varying the duty cycle of a digital signal. It’s used in applications like motor speed control and LED brightness. The microcontroller generates a square wave with a specific frequency and duty cycle, adjusting the average power delivered to the load.

// Example code for PWM on an Arduino
int pwmPin = 9; // PWM pin

void setup() {
  pinMode(pwmPin, OUTPUT);
}

void loop() {
  analogWrite(pwmPin, 128); // Set duty cycle to 50% (128/255)
  delay(1000);
  analogWrite(pwmPin, 255); // Set duty cycle to 100% (255/255)
  delay(1000);
}

3. What are the key differences between SPI and I2C communication protocols?

SPI and I2C are communication protocols with distinct differences. SPI uses four wires and offers higher data transfer rates, while I2C uses two wires and is more complex due to its addressing scheme. SPI is full-duplex, allowing simultaneous data transmission and reception, whereas I2C is half-duplex. SPI requires separate chip select lines for each device, while I2C uses an addressing scheme to share the same bus among multiple devices.

4. Explain the concept of Direct Memory Access (DMA) and its advantages.

DMA allows peripherals to access system memory directly, bypassing the CPU. This increases efficiency, reduces CPU overhead, and enables faster data transfer. A typical use case is audio processing, where DMA transfers audio data between peripherals and memory without burdening the CPU.

5. How do you handle debouncing of a mechanical switch in software?

Debouncing a mechanical switch in software involves implementing a delay or state-checking mechanism to ensure only a single signal is registered when the switch is pressed or released. This can be achieved using a timer-based approach or a state machine.

#define DEBOUNCE_DELAY 50 // 50 milliseconds

bool debounceSwitch(bool currentState) {
    static bool lastState = false;
    static unsigned long lastDebounceTime = 0;

    if (currentState != lastState) {
        lastDebounceTime = millis();
    }

    if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY) {
        if (currentState != lastState) {
            lastState = currentState;
            return currentState;
        }
    }

    return lastState;
}

6. Describe the process of configuring an external interrupt on a specific pin.

Configuring an external interrupt on a specific pin involves setting the pin as an input, enabling the interrupt, configuring the trigger condition, writing the ISR, and enabling global interrupts.

Example (pseudo-code):

// Configure pin as input
DDRx &= ~(1 << PINx);

// Enable interrupt for the pin
EIMSK |= (1 << INTx);

// Set interrupt trigger to rising edge
EICRA |= (1 << ISCxx);

// ISR for the interrupt
ISR(INTx_vect) {
    // Handle interrupt
}

// Enable global interrupts
sei();

7. What are the benefits and drawbacks of using RTOS (Real-Time Operating System) in applications?

Using an RTOS in applications offers benefits like deterministic timing, efficient task management, and modularity. However, it also introduces complexity, overhead, and a learning curve. Developers must balance these factors when deciding to use an RTOS.

8. Explain how you would perform power management in a battery-operated system.

Power management in a battery-operated system involves techniques like using sleep modes, dynamic voltage and frequency scaling, peripheral management, power gating, and writing optimized software. These strategies help extend battery life and ensure efficient operation.

9. How would you implement a bootloader for firmware updates over UART?

A bootloader facilitates firmware updates over UART by initializing the UART interface, receiving firmware data, verifying its integrity, and writing it to memory. The process involves receiving the firmware size, downloading the data, and jumping to the new application.

#include <stdint.h>
#include <stdbool.h>

#define UART_BUFFER_SIZE 256
#define FIRMWARE_START_ADDRESS 0x08004000

void UART_Init(void);
bool UART_Receive(uint8_t* buffer, uint32_t length);
void Flash_Write(uint32_t address, uint8_t* data, uint32_t length);
void JumpToApplication(void);

int main(void) {
    uint8_t buffer[UART_BUFFER_SIZE];
    uint32_t firmware_size = 0;

    UART_Init();

    // Receive firmware size
    if (UART_Receive((uint8_t*)&firmware_size, sizeof(firmware_size))) {
        uint32_t address = FIRMWARE_START_ADDRESS;

        // Receive firmware data
        while (firmware_size > 0) {
            uint32_t chunk_size = (firmware_size > UART_BUFFER_SIZE) ? UART_BUFFER_SIZE : firmware_size;
            if (UART_Receive(buffer, chunk_size)) {
                Flash_Write(address, buffer, chunk_size);
                address += chunk_size;
                firmware_size -= chunk_size;
            } else {
                // Handle receive error
                break;
            }
        }

        // Jump to the new application
        JumpToApplication();
    }

    while (1);
}

void UART_Init(void) {
    // Initialize UART peripheral
}

bool UART_Receive(uint8_t* buffer, uint32_t length) {
    // Receive data over UART
    return true;
}

void Flash_Write(uint32_t address, uint8_t* data, uint32_t length) {
    // Write data to flash memory
}

void JumpToApplication(void) {
    // Jump to the main application
}

10. How do you ensure data integrity when communicating between two devices?

Ensuring data integrity between devices involves using error detection and correction codes, communication protocols, handshaking, and redundancy. These methods help detect and correct errors during data transmission.

11. Write pseudocode to implement a non-blocking delay using a timer interrupt.

Non-blocking delays are implemented using timer interrupts, allowing the main program to continue executing other tasks while waiting for a delay to complete.

// Initialize the timer
initialize_timer(timer_value)

// Timer interrupt service routine
on_timer_interrupt:
    // Set a flag to indicate the timer has expired
    timer_expired = true

// Main program
main:
    // Set the initial state of the flag
    timer_expired = false
    
    // Start the timer
    start_timer()
    
    // Main loop
    while true:
        // Check if the timer has expired
        if timer_expired:
            // Perform the action after the delay
            perform_action()
            
            // Reset the flag
            timer_expired = false
            
            // Restart the timer if needed
            start_timer()
        
        // Perform other tasks
        perform_other_tasks()

12. Explain the role of interrupts in real-time systems.

Interrupts allow the microcontroller to pause its current task, handle a more urgent task, and then resume its previous activity. This mechanism is essential for applications that require immediate attention, such as handling sensor inputs, communication protocols, or time-sensitive operations.

#include <avr/io.h>
#include <avr/interrupt.h>

ISR(TIMER1_COMPA_vect) {
    // Interrupt Service Routine for Timer1 Compare Match A
    PORTB ^= (1 << PB0); // Toggle LED on pin PB0
}

int main(void) {
    DDRB |= (1 << PB0); // Set PB0 as output

    // Configure Timer1
    TCCR1B |= (1 << WGM12); // CTC mode
    TIMSK1 |= (1 << OCIE1A); // Enable Timer1 Compare Match A interrupt
    OCR1A = 15624; // Set compare value for 1Hz at 16MHz clock with 1024 prescaler
    TCCR1B |= (1 << CS12) | (1 << CS10); // Start Timer1 with 1024 prescaler

    sei(); // Enable global interrupts

    while (1) {
        // Main loop
    }
}

13. Describe the process of firmware over-the-air (FOTA) updates.

FOTA updates involve initiation, downloading, verification, backup, installation, reboot, and validation. These steps ensure the new firmware is downloaded, verified, and installed correctly, with a backup available in case of issues.

14. How do you ensure secure communication between microcontrollers?

Secure communication between microcontrollers involves encryption, authentication, secure key management, integrity checks, and secure boot. These strategies protect data from unauthorized access and ensure its integrity during transmission.

15. What are the considerations for selecting a microcontroller for a specific application?

When selecting a microcontroller, consider performance requirements, power consumption, peripheral support, cost, development tools, package size, environmental conditions, and scalability. Balancing these factors helps choose a microcontroller that meets the application’s needs.