Question 1

What is the primary difference between a Microcontroller (MCU) and a Microprocessor (MPU)?

Accepted Answer

• Microcontroller (MCU, e.g. ATmega328P, STM32, ESP32): A complete computer integrated onto a single silicon chip containing CPU, Flash memory, RAM, timers, ADCs, and GPIO pins. MCUs execute bare-metal firmware with microsecond deterministic real-time response and milliwatt power consumption.

• Microprocessor (MPU, e.g. Intel Core, ARM Cortex-A in Raspberry Pi): Only contains the CPU core and cache. Requires external RAM chips, external eMMC/microSD storage, and PMIC power rails. Runs full operating systems (Linux/Windows) with gigabytes of memory, perfect for high-level computer vision and neural networks but lacks microsecond real-time motor determinism.

Question 2

Which microcontroller board should a beginner choose: Arduino Uno, ESP32, or Raspberry Pi Pico?

Accepted Answer

• Arduino Uno (ATmega328P, 8-bit, 16MHz, 5V logic): Best for absolute beginners. 5V tolerant pins prevent accidental burnout, huge tutorial ecosystem, plug-and-play simplicity.

• ESP32 (Dual-Core 32-bit Xtensa, 240MHz, Wi-Fi & Bluetooth, 3.3V logic): Best all-round value ($4). Ideal for IoT robots, wireless telemetry, web servers, and Bluetooth controllers.

• Raspberry Pi Pico / RP2040 (Dual-Core ARM Cortex-M0+, 133MHz, 3.3V logic): Best for custom hardware interfacing thanks to its 8 Programmable I/O (PIO) state machines and native C++/MicroPython support.

Question 3

What is the difference between Flash Memory, SRAM, and EEPROM on microcontrollers?

Accepted Answer

• Flash Memory (Non-volatile, ROM): Stores the compiled binary firmware program and constant lookup tables. Retains data when power is disconnected (~10,000 write cycles).

• SRAM (Static RAM, Volatile): Stores runtime variables, call stacks, and dynamic buffers. Ultra-fast, but loses all data instantly when powered down.

• EEPROM (Electrically Erasable PROM, Non-volatile): Byte-addressable storage used to persist robot configuration parameters (PID gains, sensor calibration offsets, Wi-Fi credentials) across power cycles (~100,000 to 1,000,000 write cycles).

Question 4

Why should I strictly avoid using `delay()` in robotics firmware, and what should I use instead?

Accepted Answer

Calling `delay(1000)` is a blocking function that forces the CPU into a tight empty loop doing nothing for 1,000 milliseconds. During this time, the robot CANNOT read collision sensors, parse serial packets, or update motor PID loops, causing runaway collisions.

Instead, use non-blocking time checks with hardware timers or the `millis()` pattern: ```cpp unsigned long currentMillis = millis(); if (currentMillis - previousMillis >= interval) { previousMillis = currentMillis; updateSensorReading(); } ```

Question 5

What causes a Stack Overflow crash on microcontrollers, and how do I prevent it?

Accepted Answer

The call stack in SRAM grows downward to store return addresses and local variables created inside functions. If a function calls itself deeply (recursion) or declares massive local arrays (e.g. `char buffer[2048];` inside a function on an MCU with only 2KB RAM), the stack collides with the global variable heap, corrupting memory and causing a CPU reset.

Prevention: 1. Never use recursion in embedded systems. 2. Keep local variables small. 3. Make large buffers static or global.

Question 6

What is the difference between UART, I2C, and SPI serial communication protocols?

Accepted Answer

• UART (Asynchronous, 2 wires: TX/RX): Point-to-point communication between two devices (e.g. GPS module or PC debugging). No shared clock line; both devices must match baud rates (e.g. 115200 bps).

• I2C (Synchronous, 2 wires: SDA/SCL): Multi-device addressable bus with shared clock. Up to 127 sensors connected to the same 2 wires using pull-up resistors. Speeds up to 400kHz–1MHz (e.g. OLED displays, IMUs).

• SPI (Synchronous, 4 wires: MOSI/MISO/SCK/CS): High-speed full-duplex bus. Speeds up to 10MHz–50MHz. Dedicated Chip Select (CS) pin per slave device (e.g. SD cards, TFT color screens).

Question 7

Why do I2C bus lines require external 4.7kΩ pull-up resistors?

Accepted Answer

I2C lines (SDA and SCL) use open-drain / open-collector transceivers. Devices on the bus can only pull the lines LOW to 0V or let them float—no device can actively drive the line HIGH to 5V/3.3V (preventing electrical short circuits if two devices transmit simultaneously).

Pull-up resistors (typically 2.2kΩ to 4.7kΩ connected to VCC) are mandatory to pull the bus voltage back HIGH to logic 1 whenever no device is pulling it LOW.

Question 8

What is a Hardware Interrupt (ISR) and when should I use one in robotics?

Accepted Answer

A Hardware Interrupt Service Routine (ISR) is a high-priority function triggered automatically by an asynchronous hardware signal on a physical pin (e.g. a rising edge from an optical wheel encoder or an emergency stop button press).

The CPU pauses its main loop execution immediately within nanoseconds, executes the ISR, and resumes normal execution.

ISR Best Practices: 1. Keep ISR code extremely short (increment a counter or set a boolean flag). 2. Never call `delay()`, `Serial.print()`, or allocate memory inside an ISR. 3. Declare shared variables with the `volatile` keyword (e.g. `volatile long encoderTicks = 0;`).

Question 9

Can I connect a 5V sensor directly to a 3.3V microcontroller (ESP32 / STM32)?

Accepted Answer

Connecting 5V directly to a 3.3V-only microcontroller GPIO pin (like ESP32 or Raspberry Pi Pico) will inject excessive current through the internal ESD clamping diodes, causing thermal breakdown and destroying the input pin or entire chip.

Safe Interfacing Solutions: • For Unidirectional Signals (e.g. 5V Sensor TX $ o$ 3.3V MCU RX): Use a resistive voltage divider (1kΩ and 2kΩ) to divide 5V down to 3.33V. • For Bidirectional Buses (e.g. I2C SDA/SCL): Use a bidirectional logic level shifter module featuring BSS138 N-channel MOSFETs.

Question 10

What is FreeRTOS and why is it used in complex robotics firmware?

Accepted Answer

FreeRTOS is a Real-Time Operating System kernel that enables true preemptive priority-based multitasking on microcontrollers.

Instead of a single giant `loop()` function, you create independent tasks: • Task 1 (High Priority, 1000Hz): Motor PID control and balance calculations. • Task 2 (Medium Priority, 50Hz): Ultrasonic sensor distance acquisition. • Task 3 (Low Priority, 10Hz): Wi-Fi telemetry and OLED display rendering.

If the Wi-Fi task takes 100ms, the RTOS preempts it immediately to guarantee the motor PID loop fires on exact millisecond intervals without jitter.

Question 11

Why does dynamic memory allocation (`malloc` and `new`) cause crashes on microcontrollers?

Accepted Answer

Unlike desktop computers with virtual memory management and gigabytes of RAM, microcontrollers have tiny flat SRAM (e.g. 2KB on Arduino Uno, 320KB on ESP32).

Repeatedly allocating and freeing arbitrary-sized heap buffers (such as using `String` objects in C++) breaks SRAM into tiny discontinuous unusable memory holes (Heap Fragmentation). Eventually, `malloc()` fails to find a contiguous block, returns NULL, and dereferencing the pointer crashes the robot. Always pre-allocate static arrays!

Question 12

What is Direct Memory Access (DMA) and how does it accelerate robotics perception?

Accepted Answer

Direct Memory Access (DMA) is a dedicated silicon hardware engine that transfers data directly between high-speed peripherals (such as SPI cameras, ADC sensors, or UART LiDARs) and SRAM without consuming any CPU cycles.

While the DMA controller streams 300,000 bytes of camera pixel data into RAM in the background, the CPU is 100% free to compute motor kinematics and path planning simultaneously.

Microcontrollers & Coding Frequently Asked Questions