Embedded Systems & IoT MCQ

Explanation

Embedded systems are purpose-built computing systems (e.g., in appliances, cars, or sensors) designed for specific tasks, typically with limited resources compared to general-purpose computers.

Explanation

IoT (Internet of Things) refers to a network of physical devices embedded with sensors, software, and connectivity that exchange data with other devices or systems over the internet.

Explanation

Microcontrollers integrate a CPU, RAM, flash storage, and I/O peripherals on a single chip, making them ideal for dedicated control tasks in embedded devices with low cost and power requirements.

Explanation

Microcontrollers are designed for self-contained control tasks (integrating RAM, ROM, I/O), while microprocessors (like those in PCs) are general-purpose CPUs that rely on external components for a complete system.

Explanation

Firmware provides the basic instructions for a device's hardware to operate, often stored in flash memory or ROM, and is closer to the hardware than typical application software.

Explanation

GPIO pins allow a microcontroller to read signals from sensors (input) or control devices like LEDs and motors (output), forming a basic interface to the physical world.

Explanation

Analog signals (like a temperature reading from a sensor) vary smoothly, while digital signals use discrete levels (often two: high/low) — many embedded systems use ADCs to convert analog signals to digital for processing.

Explanation

ADCs sample an analog input (e.g., from a temperature sensor) and produce a corresponding digital value, enabling microcontrollers — which process digital data — to read analog real-world signals.

Explanation

Sensors are the "input" devices of embedded/IoT systems, converting real-world phenomena into electrical signals that the system can read and act upon.

Explanation

Actuators are the "output" devices that let an embedded system affect the physical world — for example, a motor turning a fan based on a temperature reading from a sensor.

Explanation

Interrupts allow a microcontroller to respond immediately to important events (like a button press or sensor trigger) without constantly checking ("polling") for them in the main loop.

Explanation

Polling consumes CPU cycles even when nothing has changed, while interrupts let the CPU do other work (or sleep) until an event occurs, often improving efficiency and responsiveness.

Explanation

RTC modules maintain accurate timekeeping independent of the main system clock, often used for timestamping data, scheduling tasks, or logging events even after power loss.

Explanation

RAM holds variables and runtime data, cleared on power loss, while flash memory stores the program (firmware) persistently, allowing the device to boot and run the same code after a restart.

Explanation

PWM varies the proportion of time a signal is "on" versus "off" (duty cycle) within a fixed period, effectively controlling the average voltage/power delivered, used for dimming LEDs, motor speed control, etc.

Explanation

Bootloaders run before the main application, often allowing firmware updates to be loaded onto the device (e.g., via USB or serial) without specialized programming hardware.

Explanation

UART is a simple, widely used serial communication protocol for point-to-point connections, commonly used for debugging output, GPS modules, and communication between microcontrollers.

Explanation

I2C uses two wires (SDA for data, SCL for clock) to connect multiple devices on a shared bus, each with a unique address, commonly used for connecting sensors and small peripherals.

Explanation

SPI uses separate clock and data lines (often with a chip-select line per device) for fast, full-duplex communication, commonly used for displays, memory chips, and other high-speed peripherals.

Explanation

RTOSes (like FreeRTOS) guarantee that tasks complete within defined deadlines, which is crucial for applications like industrial control or medical devices where timing is critical.

Explanation

Hard real-time systems (e.g., airbag deployment) must meet deadlines absolutely, while soft real-time systems (e.g., video streaming) can tolerate occasional delays with reduced quality rather than total failure.

Explanation

If the main program fails to reset ("feed") the watchdog timer within a set period (e.g., due to a crash or infinite loop), the watchdog triggers a system reset, improving reliability in unattended devices.

Explanation

Wi-Fi provides relatively high-bandwidth wireless connectivity for IoT devices to communicate with local networks and the internet, though it consumes more power than some other IoT protocols.

Explanation

BLE is optimized for devices that need to send small amounts of data occasionally while conserving battery life, common in wearables, beacons, and smart home sensors.

Explanation

MQTT uses a broker-based publish-subscribe model, allowing IoT devices to send small messages efficiently with minimal overhead, suitable for constrained devices and unreliable connections.

Explanation

Sleep modes selectively power down parts of a microcontroller (CPU, peripherals) while retaining enough state to wake up on an interrupt or timer, crucial for battery-powered IoT devices.

Explanation

Mechanical switches can produce multiple rapid on/off transitions ("bounce") when pressed; debouncing (in hardware or software) ensures this is treated as a single clean press.

Explanation

Development boards provide ready-made hardware platforms with common interfaces, making it easy to prototype, test code, and iterate before committing to custom PCB designs for production.

Explanation

Arduino boards run simple compiled code directly on a microcontroller with no OS, ideal for low-level control with predictable timing, while Raspberry Pi runs Linux and is better suited for tasks needing more processing power, networking, or a file system.

Explanation

OTA updates allow manufacturers to push bug fixes, security patches, or new features to deployed devices remotely, which is essential for managing large fleets of IoT devices in the field.

Explanation

Data loggers periodically sample and store sensor readings (e.g., temperature over a day), useful for monitoring trends, debugging, or generating reports without constant live connectivity.

Explanation

Edge computing reduces latency, bandwidth usage, and reliance on connectivity by performing computation closer to where data is generated, sending only relevant results to the cloud.

Explanation

Many components (like microcontrollers) require a specific stable voltage (e.g., 3.3V); voltage regulators ensure components receive the correct voltage even if the power source voltage varies.

Explanation

Without a pull-up or pull-down resistor, an unconnected ("floating") digital input can read random noise as high or low; these resistors bias the pin to a known default state when not actively driven by another source.

Explanation

This distinction is critical in embedded design: program code and configuration that must survive power loss go in non-volatile memory (flash/EEPROM), while temporary variables use volatile RAM.

Explanation

Embedded targets often can't run a full compiler themselves due to resource constraints, so developers cross-compile on a more powerful host machine, producing binaries for the target's specific architecture (e.g., ARM).

Explanation

JTAG provides a standardized interface for hardware debugging — setting breakpoints, inspecting registers, and flashing firmware directly onto a chip — invaluable during embedded development.

Explanation

ESP32/ESP8266 chips are popular in IoT development because they combine a capable microcontroller with built-in wireless connectivity at low cost, making internet-connected projects easy and affordable.

Explanation

Microcontrollers need a consistent clock signal to execute instructions and synchronize timing-dependent peripherals; crystal oscillators provide a precise, stable frequency reference for this purpose.

Explanation

Breadboards let developers quickly prototype and test circuits by plugging in components and jumper wires without soldering, making it easy to experiment and iterate before finalizing a design.

Explanation

Dynamic memory allocation can lead to fragmentation and unpredictable failures over long uptimes with limited RAM; statically allocated buffers (sized at compile time) provide deterministic, predictable memory behavior.

Explanation

DMA controllers handle bulk data transfers (e.g., from an ADC or UART to memory) independently of the CPU, significantly improving efficiency for high-throughput peripherals.

Explanation

Preemptive scheduling (common in RTOSes) allows higher-priority tasks to interrupt lower-priority ones, improving responsiveness, but requires careful handling of shared resources; cooperative multitasking relies on tasks yielding voluntarily, which can be simpler but risks one task monopolizing the CPU.

Explanation

Priority inversion can cause critical tasks to miss deadlines; solutions like priority inheritance temporarily raise the priority of the lower-priority task holding the resource to prevent excessive delay.

Explanation

When an interrupt handler and the main program (or multiple tasks) access shared variables without proper synchronization (e.g., disabling interrupts or using mutexes), the resulting behavior can be inconsistent and hard to debug.

Explanation

Without "volatile", the compiler might cache a variable's value in a register, missing updates made by an interrupt handler; "volatile" forces every access to read/write the actual memory location.

Explanation

The bootrom is immutable code in the chip's silicon that performs minimal initialization (clocks, memory) and loads the next stage of boot code, which can then load a full OS or application firmware.

Explanation

Choosing a wireless protocol involves trade-offs between range, power consumption, data rate, and network topology — Wi-Fi for high data needs near power, Zigbee for low-power mesh sensor networks, LoRa for long-range, low-data telemetry.

Explanation

CAN bus provides reliable, real-time, multi-node communication for automotive and industrial systems, with built-in error detection and message prioritization, without requiring a central host.

Explanation

Memory-mapped I/O lets developers control hardware (e.g., set a GPIO pin) by writing to specific memory addresses, simplifying interaction with peripherals using the same instructions used for RAM.

Explanation

By powering down unused blocks (e.g., a radio module when not transmitting), power gating reduces both dynamic and static (leakage) power consumption, extending battery life in portable devices.

Explanation

Drivers abstract the low-level details of communicating with hardware (registers, interrupts), allowing application code and the OS to interact with devices through a consistent API.

Explanation

Secure boot uses cryptographic signatures to ensure only firmware signed by a trusted authority can run, protecting against attackers who might try to flash malicious firmware onto a device.

Explanation

TLS provides encrypted, authenticated communication channels, which is important for IoT devices sending sensitive data (like sensor readings or credentials) over potentially insecure networks.

Explanation

Constrained devices often use techniques like A/B (dual-bank) partitions, allowing the new firmware to be written to an inactive bank and verified before switching, with the ability to roll back if the update fails.

Explanation

Connecting a 5V output directly to a 3.3V input can damage the lower-voltage device or cause unreliable signals; level shifters safely translate voltage levels between mismatched components.

Explanation

RMS is a fixed-priority scheduling algorithm commonly analyzed in real-time systems: it assigns priorities inversely proportional to task period, which has provable schedulability guarantees under certain conditions.

Explanation

Lightweight network stacks (e.g., lwIP) implement essential networking layers in a memory-efficient way, allowing constrained microcontrollers to participate in TCP/IP networks for IoT connectivity.

Explanation

While most embedded code is written in C/C++ for portability and maintainability, small critical sections (interrupt vectors, precise timing loops, startup code) sometimes use assembly for fine-grained control.

Explanation

If voltage drops too low (a "brown-out"), a microcontroller might execute instructions unreliably or corrupt memory; brown-out detection resets the device to a known state until power stabilizes.

Explanation

Raw sensor readings often contain noise; simple digital filters like moving averages or low-pass filters smooth out short-term fluctuations, improving the reliability of measurements used for control decisions.

Explanation

Different architectures (e.g., ARM vs. some network protocols) may use different byte orderings for multi-byte values; communication protocols often define a specific "network byte order" to ensure consistent interpretation.

Explanation

Static discharge from human contact or cables can damage sensitive ICs; ESD protection components (TVS diodes, etc.) divert excess voltage away from sensitive circuitry, especially on externally accessible connectors.

Explanation

The choice depends on the application — e.g., minor precision loss in a temperature reading might be acceptable with lossy compression to save bandwidth, while financial or critical measurement data may require lossless methods.

Explanation

State machines clearly define what states a system can be in (e.g., idle, running, error) and how it transitions between them, making embedded control logic (like a washing machine controller) easier to design, test, and debug.

Explanation

Gateways bridge low-power, short-range sensor networks to the internet, allowing sensors to use cheaper, lower-power radios while the gateway handles internet connectivity, protocol translation, and possibly edge processing.

Explanation

After an unexpected reset, checking the reset cause register helps determine if it was due to a watchdog timeout (suggesting a software hang), brown-out (power issue), or a normal power cycle, aiding debugging.

Explanation

Industrial control loops often require guarantees that sensor data and commands arrive within a known time window; protocols designed for determinism (e.g., certain industrial Ethernet variants) avoid unpredictable delays from collisions or retries.

Explanation

By abstracting low-level register access behind a common API, a HAL lets developers write application logic that can be reused across different hardware platforms by swapping out the underlying HAL implementation.

Explanation

Individual sensors of the same model can have slight manufacturing variations; calibration against known reference conditions (e.g., a known temperature) allows the system to apply correction factors for more accurate readings.

Explanation

The choice depends on factors like installation cost, environment (electrical noise, mobility needs), reliability requirements, and whether power-over-cable (e.g., PoE) is beneficial versus battery-powered wireless flexibility.

Explanation

When multiple tasks might access shared data (like a sensor buffer), a mutex locks access so only one task modifies it at a time, preventing corrupted or inconsistent data from concurrent access.

Explanation

I2C's addressing scheme allows many devices to share two wires at lower speed, while SPI's per-device chip-select lines and separate data lines enable faster communication at the cost of more pins as device count grows.

Explanation

Repeatedly writing to the same flash blocks (e.g., for frequent logging) can wear them out prematurely; wear-leveling algorithms distribute writes across the available memory to avoid early failure of specific cells.

Explanation

ISRs should execute as quickly as possible; placing data into a queue (a non-blocking operation) and returning lets a lower-priority task handle the actual processing, reducing the time interrupts are disabled and improving overall responsiveness.

Explanation

Provisioning ensures each device in a fleet has its own unique identity (certificates, keys, configuration) so it can be individually authenticated and managed, which is essential for security and device management at scale.

Explanation

A built-in watchdog depends on the same chip that might be malfunctioning; an external watchdog IC operates independently, providing an extra layer of resilience by resetting the system if it doesn't receive a periodic "heartbeat" signal.

Explanation

Choosing a sleep mode involves a trade-off between power savings and wake-up latency/state retention — deep sleep saves the most power but may require more time and reinitialization to resume normal operation.

Explanation

Ring buffers use a fixed-size array with wrap-around indexing, making them ideal for buffering continuous data streams (like UART received bytes) in memory-constrained systems without the overhead of dynamic allocation.

Explanation

CRC and checksum values are computed from the data before transmission and recomputed by the receiver; a mismatch indicates the data was corrupted in transit, allowing the receiver to request retransmission or discard the bad data.

Explanation

Because embedded stacks are often small fixed-size regions without memory protection, overflowing into adjacent memory can silently corrupt other data structures, leading to bugs that appear unrelated to the actual cause — often debugged using stack canaries or RTOS stack-overflow checks.

Explanation

MPUs (common in Cortex-M microcontrollers) add a layer of fault detection by enforcing access rules on physical memory regions (e.g., preventing a task from writing to another task's memory), without the overhead and complexity of full virtual memory translation found in MMUs.

Explanation

A device that wakes briefly to sample sensors and transmit, then returns to a microamp-level sleep state for most of its time, can achieve dramatically longer battery life than one that remains active, since active/radio current draw can be 100-1000x higher than sleep current.

Explanation

Power analysis (e.g., differential power analysis) or timing attacks can reveal secret key bits by correlating physical measurements with operations performed during cryptographic computations, even if the algorithm itself is mathematically sound — mitigated by constant-time implementations and hardware countermeasures.

Explanation

Without coherency protocols (or explicit cache management like flush/invalidate operations), one core's cached value of shared data could become inconsistent with what another core has written, leading to subtle bugs — a major consideration in multi-core embedded designs.

Explanation

Even with secure boot verifying signatures, an attacker might try to install an older, legitimately-signed but vulnerable firmware version; rollback protection (e.g., monotonic version counters in secure storage) prevents booting firmware older than a minimum allowed version.

Explanation

Unlike CSMA, where nodes contend for the channel and may experience collisions and variable delay, TDMA divides time into slots assigned to specific nodes, providing deterministic, collision-free access — but requires all nodes to maintain synchronized clocks, which itself is a non-trivial distributed systems problem.

Explanation

A watchdog is meant to catch failures in the overall system; if a simple timer interrupt feeds it independent of whether the application's critical logic is actually executing correctly, the main application could hang forever while the watchdog continues being satisfied — undermining its safety purpose.

Explanation

Without hardware floating-point support, floating-point operations are emulated in software, which is slow; fixed-point arithmetic (using scaled integers) can be dramatically faster for resource-constrained, real-time tasks, though it requires careful management of scaling and range to avoid overflow or precision loss.

Explanation

Standard TLS typically authenticates only the server to the client; mTLS adds client certificate verification, so the server can cryptographically confirm the identity of each connecting device — important for ensuring only legitimate devices in a fleet can communicate.

Explanation

Many control algorithms (like PID controllers) are designed assuming a fixed time step; if the actual interval between executions varies significantly (jitter), the computed control output can become less accurate or even unstable.

Explanation

In environments with elevated radiation (e.g., high altitude, space), random bit flips in memory ("soft errors") become more likely; ECC memory uses additional bits to detect and correct single-bit errors, improving data integrity.

Explanation

A robust OTA scheme keeps the previous working firmware intact in the inactive partition; if the new firmware fails to mark itself as successfully booted (e.g., crashes repeatedly), the bootloader falls back to the known-good partition, preventing a "bricked" device.

Explanation

Timing-sensitive bugs (race conditions, missed deadlines) can be "Heisenbugs" that vanish when a debugger pauses execution; non-intrusive trace mechanisms capture execution data with minimal impact on real-time behavior, helping diagnose issues that only occur during actual runtime conditions.

Explanation

Buffering data locally (in flash or RAM, depending on volume and power constraints) during connectivity gaps, combined with retry/acknowledgment protocols upon reconnection, ensures data captured during outages isn't lost — common in remote/cellular IoT deployments.

Explanation

Mesh networks (Zigbee, Thread) allow devices to relay data, extending effective range and providing redundant paths if a node fails, but relay nodes consume more power and routing adds complexity; star topologies are simpler to manage but depend entirely on a central coordinator's range and uptime.

Explanation

Embedded devices often lack good entropy sources at boot, which has historically led to predictable keys when relying solely on PRNGs; hardware RNGs that sample physical noise sources provide higher-quality entropy critical for secure key generation.

Explanation

Sustained computational loads generate heat; without sufficient cooling (heatsinks, airflow), an SoC may throttle its clock speed to stay within safe temperature limits, meaning a system designed for peak performance must plan for sustained throughput under thermal constraints.

Explanation

By encoding a signal as the voltage difference between two wires carrying complementary signals, differential receivers can subtract out noise that affects both wires similarly (common-mode noise), making protocols like RS-485 robust over long industrial cable runs.

Explanation

TLS handshakes involve computationally expensive public-key operations; on constrained microcontrollers, the smaller keys and faster operations of ECC compared to RSA at equivalent security levels can make the difference between a feasible and infeasible secure connection given limited resources.