Embedded interview

RTOS
o Semaphore, Mutex, Scheduling Algorithms, Race Condition, Multi-threading

Microprocessor Architecture

Embedded C

What does Compiler & Linker do?

Startup Code, LinkerFile, MapFile

Stack and Heap as sections of RAM

Journey of a Firmware from the compiling stage to main function’s first line.

Common Serial Communication Protocols

Bluetooth Low Energy and BLE 5.1 Standards (just the basics)

NB-IoT, LTE-M, LoRa (just the basic)

Sure, let's delve deeper into each topic with five questions for an embedded
software engineering intern position:

RTOS:
1. Question: What are the advantages and disadvantages of using
semaphores compared to mutexes in an RTOS environment?
Answer: Semaphores allow multiple tasks to access a shared resource
simultaneously, whereas mutexes ensure exclusive access. Semaphores
are suitable for scenarios where multiple tasks can operate on a resource
concurrently, but they are more complex to manage and prone to priority
inversion. Mutexes, on the other hand, provide simpler ownership
semantics but can lead to deadlocks if not used carefully.

2. Question: How would you choose the appropriate scheduling algorithm for
a real-time embedded system in a healthcare device? What factors would
you consider?
Answer: Factors to consider when selecting a scheduling algorithm include
task deadlines, priority levels, and resource constraints. For a healthcare
device, where timely processing of critical tasks is paramount, an algorithm

Embedded interview 1
 like Earliest Deadline First (EDF) or Rate Monotonic Scheduling (RMS) might
be suitable. These algorithms prioritize tasks based on their deadlines or
periods, ensuring critical tasks are executed in a timely manner.

3. Question: Explain how you would identify and resolve a race condition in a
multi-threaded application running on an RTOS.
Answer: Race conditions occur when multiple threads access shared
resources concurrently without proper synchronization, leading to
unpredictable behavior. To identify race conditions, thorough code review
and testing are essential. Techniques such as using mutexes or
semaphores to synchronize access to shared resources can mitigate race
conditions. Additionally, tools like static code analyzers and runtime
debugging tools can help detect potential race conditions and pinpoint their
sources.

4. Question: What are the key differences between preemptive and non-
preemptive scheduling in an RTOS, and in what scenarios would you
choose one over the other?
Answer: Preemptive scheduling allows higher priority tasks to interrupt
lower priority tasks, while non-preemptive scheduling requires a task to
voluntarily relinquish control before another task can execute. Preemptive
scheduling provides better responsiveness and is suitable for systems with
time-critical tasks. Non-preemptive scheduling, on the other hand,
simplifies task synchronization and is often used in systems with
predictable task execution times.

5. Question: Can you explain how context switching works in an RTOS and
discuss its impact on system performance?

Answer: Context switching involves saving the state of a task, such as its
program counter and register values, and loading the state of another task
to resume execution. In an RTOS, context switching occurs when the
scheduler decides to switch from one task to another based on scheduling
policies. Context switching introduces overhead, including saving and
restoring task states, which can impact system performance, especially in
systems with tight timing constraints. Optimizing context switch time
through efficient scheduling algorithms and minimizing unnecessary
interrupts can help mitigate this impact.

Microprocessor Architecture:

Embedded interview 2
 1. Question: Describe the role of the program counter (PC) in the execution of
instructions on a microprocessor.

Answer: The program counter (PC) is a register that holds the memory
address of the next instruction to be fetched and executed by the
microprocessor. During each instruction cycle, the microprocessor fetches
the instruction pointed to by the PC, increments the PC to point to the next
instruction, and executes the fetched instruction.

2. Question: What is the significance of the stack pointer (SP) register in

microprocessor architecture, and how is it used during subroutine calls?

Answer: The stack pointer (SP) register points to the top of the stack, a
region of memory used for storing temporary data and return addresses
during subroutine calls. When a subroutine is called, the microprocessor
pushes the return address onto the stack and updates the SP accordingly.
Upon returning from the subroutine, the return address is popped from the
stack, and the SP is restored to its original value.

3. Question: Explain the difference between Harvard and von Neumann

architectures in microprocessors.
Answer: In a Harvard architecture, separate memory spaces are used for
instructions and data, allowing simultaneous access to both. In contrast, a
von Neumann architecture uses a single memory space for both
instructions and data, leading to potential bottlenecks in fetching
instructions and accessing data. Harvard architectures are often found in
embedded systems where performance and parallelism are critical, while
von Neumann architectures are more common in general-purpose
computing systems.

4. Question: What is the purpose of the memory management unit (MMU) in

microprocessor architecture, and how does it facilitate memory protection?

Answer: The memory management unit (MMU) is responsible for

translating virtual addresses generated by the CPU into physical addresses
used to access memory. It facilitates memory protection by implementing
memory access control mechanisms, such as read/write permissions and
memory segmentation. By enforcing memory protection, the MMU helps
prevent unauthorized access to critical system resources and improves
system reliability.

Embedded interview 3
 5. Question: Discuss the role of interrupts in microprocessor architecture and
their importance in real-time embedded systems.

Answer: Interrupts are asynchronous events that temporarily suspend the

execution of the main program to handle time-critical tasks or respond to
external events. In real-time embedded systems, interrupts play a crucial
role in ensuring timely response to events such as sensor inputs or
communication requests. By prioritizing and servicing interrupts efficiently,
embedded systems can maintain responsiveness and meet stringent timing
requirements.

Embedded C:
1. Question: What are the differences between 'volatile' and 'const' qualifiers
in embedded C, and when would you use each?

Answer: The 'volatile' qualifier informs the compiler that a variable's value
may change unexpectedly, such as in the case of hardware registers or
global variables accessed by interrupt service routines. On the other hand,
the 'const' qualifier indicates that a variable's value remains constant
throughout its lifetime and can be used for optimization purposes. 'Volatile'
is typically used for variables that can be modified outside the program's
control, while 'const' is used for variables whose values should not change
during program execution.

2. Question: Explain the role of bit manipulation in embedded C programming

and provide an example of its usage.

Answer: Bit manipulation involves directly accessing and modifying

individual bits within a variable to perform tasks such as setting or clearing
specific flags, controlling hardware peripherals, or optimizing memory
usage. For example, in embedded systems with limited memory, bit
manipulation can be used to pack multiple status flags into a single
variable, saving memory space and improving efficiency.

3. Question: Discuss the importance of memory management in embedded C

programming and techniques for efficient memory utilization.

Answer: Memory management is crucial in embedded C programming to

ensure efficient utilization of limited resources such as RAM and flash
memory. Techniques for efficient memory management include dynamic
memory allocation, static memory allocation, and memory pooling.
Additionally, careful consideration of data structures and optimization of

Embedded interview 4
 variable types can help minimize memory overhead and improve overall
system performance.

4. Question: How do you handle code portability in embedded C

programming, especially when targeting different microcontroller
architectures?

Answer: Code portability in embedded C programming involves writing

code that can be easily adapted to different microcontroller architectures
without significant modifications. To achieve this, it's essential to abstract
hardware-dependent code into separate modules or layers, encapsulating
hardware-specific details behind standardized interfaces. Additionally,
using preprocessor directives, such as #ifdef and #define, to condition

ally compile architecture-specific code can facilitate portability across different

platforms.

1. Question: Explain the significance of linker scripts in embedded C

programming and how they are used to control memory layout.

Answer: Linker scripts define the memory layout of an embedded

application, specifying the location and size of code, data, and stack
sections in memory. By customizing linker scripts, developers can optimize
memory usage, ensure proper alignment of memory sections, and manage
memory constraints specific to the target microcontroller. Linker scripts
also enable developers to integrate external libraries and manage memory-
mapped hardware peripherals efficiently.

Compiler & Linker:

1. Question: What is the role of the compiler in embedded software
development, and how does it translate high-level code into machine-
readable instructions?
Answer: The compiler translates high-level programming language code,
such as C or C++, into machine-readable instructions that can be executed
by the target microcontroller. This process involves lexical analysis, syntax
parsing, semantic analysis, optimization, and code generation. The
compiler ensures that the resulting machine code is efficient, optimized,
and compatible with the target hardware architecture.

2. Question: Explain the function of the linker in the software development

process and how it resolves symbols and dependencies.

Embedded interview 5
 Answer: The linker is responsible for combining object files generated by
the compiler into a single executable program or firmware image. It
resolves symbols by matching references in one object file with definitions
in other object files or libraries. Additionally, the linker resolves
dependencies between modules and performs memory allocation and
address assignment based on the target hardware architecture and linker
script specifications.

3. Question: Describe the purpose of startup code in embedded software

development and its role in initializing hardware peripherals and setting up
the execution environment.

Answer: Startup code is the initial code executed when a microcontroller

boots up or resets. Its primary role is to initialize essential hardware
peripherals, such as clocks, timers, and interrupt controllers, and set up the
execution environment for the main application code. Startup code typically
configures the stack pointer, initializes global variables, and performs any
necessary hardware-specific initialization before transferring control to the
main function.

4. Question: What is a linker file, and how does it define the memory layout of
an embedded application?

Answer: A linker file, also known as a linker script, is a configuration file

that specifies the memory layout of an embedded application, including the
location and size of code, data, and stack sections in memory. Linker files
are written in a specific scripting language and provide instructions to the
linker on how to allocate memory resources and resolve symbols. By
customizing linker files, developers can optimize memory usage and ensure
proper initialization of memory-mapped hardware peripherals.

5. Question: Discuss the role of the map file generated by the linker and how
it provides valuable insight into memory usage and symbol allocation.
Answer: The map file generated by the linker provides a detailed summary
of memory usage, including the size and location of code and data
sections, as well as information about symbol allocation and relocation.
Map files help developers analyze memory usage, identify potential
optimization opportunities, and troubleshoot issues such as memory
fragmentation or symbol conflicts. By reviewing the map file, developers
can ensure efficient memory utilization and avoid common pitfalls in
embedded software development.

Embedded interview 6
 Startup Code, Linker File, Map File:
1. Question: How does the startup code initialize the stack pointer and why is
it necessary for embedded applications?
Answer: The startup code initializes the stack pointer by setting its initial
value to the top of the stack memory region. This is necessary because the
stack is used for storing local variables, function parameters, and return
addresses during program execution. By initializing the stack pointer, the
startup code ensures that the stack is properly configured before the
execution of the main application code begins.

2. Question: Explain the contents of a typical linker file used in embedded

software development and how it influences the memory layout of the final
firmware image.

Answer: A linker file contains directives that specify the memory layout of
the final firmware image, including the location and size of code, data, and
stack sections in memory. It also defines the memory regions available on
the target hardware and specifies the entry point for the application code.
By customizing the linker file, developers can optimize memory usage,
ensure proper initialization of memory-mapped peripherals, and resolve
symbol dependencies.

3. Question: What information can be found in the map file generated by the
linker, and how is it useful for embedded software developers?

Answer: The map file generated by the linker provides detailed information
about memory usage, including the size and location of code and data
sections, as well as symbol allocation and relocation information. It helps
developers analyze memory usage, identify potential optimization
opportunities, and troubleshoot issues such as memory fragmentation or
symbol conflicts. By reviewing the map file, developers can ensure efficient
memory utilization and avoid common pitfalls in embedded software
development.

4. Question: Discuss the role of the linker in resolving symbol dependencies

and how it links together object files to generate a final firmware image.
Answer: The linker resolves symbol dependencies by matching references
in one object file with definitions in other object files or libraries. It
combines multiple object files generated by the compiler into a single
executable program or firmware image, ensuring that all symbols are

Embedded interview 7
 properly linked and resolved. Additionally, the linker performs memory
allocation and address assignment based on the target hardware
architecture and linker script specifications.

5. Question: How does the linker script influence the memory layout of an
embedded application, and why is it important for optimizing memory
usage?
Answer: The linker script defines the memory layout of an embedded
application, including the location and size of code, data, and stack
sections in memory. It plays a crucial role in optimizing memory usage by
specifying memory regions, alignment constraints, and symbol locations.
By customizing the linker script, developers can optimize memory
utilization, ensure proper initialization of memory-mapped peripherals, and
resolve symbol dependencies, leading to more efficient and reliable
embedded software.

Stack and Heap as Sections of RAM:

1. Question: Explain the concept of stack and heap memory in embedded
systems, and discuss their respective usage scenarios.
Answer: In embedded systems, the stack is typically used for storing local
variables, function parameters, return addresses, and context information
during subroutine execution. It grows and shrinks dynamically as functions
are called and returned. On the other hand, the heap is a region of memory
used for dynamic memory allocation, where memory blocks can be
allocated and deallocated as needed during runtime. The stack is typically
more limited in size and fixed at compile time, while the heap can grow
dynamically but requires more careful memory management to prevent
fragmentation and memory leaks.

2. Question: What are the potential risks associated with stack and heap
overflow in embedded systems, and how can they be mitigated?
Answer: Stack overflow occurs when the stack size exceeds its predefined
limit, typically resulting in unpredictable behavior or program crashes. Heap
overflow occurs when memory allocated on the heap exceeds its bounds,
potentially leading to data corruption or security vulnerabilities. To mitigate
these risks, developers can carefully manage stack and heap usage by
optimizing stack size, avoiding excessively recursive function calls, and

Embedded interview 8
 implementing memory allocation strategies such as pooling or garbage
collection to prevent heap fragmentation and overflow.

3. Question: Discuss the role of the stack pointer (SP) register in managing
stack memory in embedded systems.

Answer: The stack pointer (SP) register points to the top of the stack
memory region and is used by the processor to push and pop data during
subroutine calls and returns. When a function is called, the SP is
decremented to allocate space for function parameters and local variables,
and when the function returns, the SP is incremented to release that space.
By properly managing the SP and ensuring it remains within the bounds of
the stack memory region, developers can prevent stack overflow and
maintain system stability.

4. Question: How does dynamic memory allocation work in embedded

systems, and what are the advantages and disadvantages compared to
static memory allocation?
Answer: Dynamic memory allocation in embedded systems involves
allocating and deallocating memory blocks from the heap at runtime using
functions like malloc() and free(). Dynamic allocation offers flexibility in
managing memory resources and can adapt to varying runtime
requirements. However, it comes with overhead in terms of memory
fragmentation, allocation/deallocation time, and the risk of memory leaks if
not managed properly. Static memory allocation, on the other hand,
allocates memory at compile time, offering deterministic behavior and
reduced runtime overhead but limited flexibility.

5. Question: Explain how stack and heap memory are initialized and managed
during the startup process of an embedded application.
Answer: During the startup process of an embedded application, the stack
and heap memory regions are typically initialized by the startup code. The
stack pointer (SP) register is initialized to the top of the stack memory
region, and the heap memory region is initialized to an initial state. As the
program executes, the stack grows and shrinks dynamically as functions
are called and returned, while the heap grows and shrinks dynamically as
memory blocks are allocated and deallocated using dynamic memory
allocation functions.

Journey of a Firmware:

Embedded interview 9
 1. Question: Describe the journey of firmware from the compilation stage to
the execution of the main function's first line.

Answer: The journey of firmware begins with the compilation of source

code written in embedded C using a compiler specific to the target
microcontroller architecture. The compiler translates the source code into
machine-readable instructions and generates object files. These object
files, along with any necessary startup code, linker files, and libraries, are
then passed to the linker, which combines them into a single executable
firmware image. During the startup process, the microcontroller initializes
essential hardware peripherals, sets up the execution environment, and
loads the firmware image into memory. Finally, control is transferred to the
main function's first line, and the firmware begins executing its intended
tasks.

2. Question: What are the key components involved in the build process of
firmware, and how do they interact with each other?
Answer: The build process of firmware typically involves several
components, including source code written in embedded C, a compiler
specific to the target microcontroller architecture, linker files specifying the
memory layout, startup code initializing hardware peripherals, and libraries
providing reusable code modules. These components interact with each
other through the build system, which orchestrates the compilation, linking,
and generation of the final firmware image. The compiler translates the
source code into machine-readable instructions, the linker combines object
files into an executable image, and the startup code initializes the hardware
environment before executing the firmware.

3. Question: Discuss the significance of linker files and map files in the
firmware development process and how they influence memory layout and
resource allocation.
Answer: Linker files, also known as linker scripts, define the memory layout
of the firmware image, specifying the location and size of code, data, and
stack sections in memory. They play a crucial role in optimizing memory
usage, ensuring proper initialization of memory-mapped peripherals, and
resolving symbol dependencies. Map files generated by the linker provide
detailed information about memory usage, symbol allocation, and
relocation, helping developers analyze memory utilization, identify
optimization opportunities, and troubleshoot issues such as memory
fragmentation or symbol conflicts.

Embedded interview 10
 4. Question: How does the firmware development process differ from
traditional software development, and what are the unique challenges and
considerations involved?
Answer: Firmware development differs from traditional software
development in several ways, including the constrained resources of
embedded systems, real-time requirements, and direct interaction with
hardware peripherals. Developers must consider factors such as memory
usage, power consumption, and timing constraints when designing and
implementing firmware. Additionally, firmware development often requires
low-level programming skills, knowledge of microcontroller architectures,
and familiarity with embedded development tools and techniques. Testing
and debugging firmware can also be more challenging due to limited
visibility into system internals and hardware dependencies.

5. Question: Explain the role of startup code in the firmware development

process and its importance in initializing hardware peripherals and setting
up the execution environment.
Answer: Startup code is the initial code executed when a microcontroller
boots up or resets. Its primary role is to initialize essential hardware
peripherals, such as clocks, timers, and interrupt controllers, and set up the
execution environment for the main application code. Startup code typically
configures the stack pointer, initializes global variables, and performs any
necessary hardware-specific initialization before transferring control to the
main function. By properly initializing the hardware environment, startup
code ensures that the firmware operates correctly and reliably on the target
hardware platform.

Common Serial Communication Protocols:

1. Question: Compare and contrast UART, SPI, and I2C serial communication
protocols in terms of their features, advantages, and typical use cases.

Answer: UART (Universal Asynchronous Receiver-Transmitter) is a simple,

asynchronous protocol commonly used for point-to-point communication
between two devices. SPI (Serial Peripheral Interface) is a synchronous,
full-duplex protocol suitable for high-speed communication between a
master device and multiple slave devices. I2C (Inter-Integrated Circuit) is a
multi-master, serial bus protocol ideal for communication between
integrated circuits with short-distance communication needs. Each protocol

Embedded interview 11
 has its own advantages and is selected based on factors such as speed,
distance, number of devices, and simplicity of implementation.

2. Question: Discuss the key features and advantages of the CAN (Controller
Area Network) serial communication protocol, and provide examples of its
use in embedded systems.
Answer: CAN (Controller Area Network) is a robust, differential serial
communication protocol designed

for high-speed communication in automotive and industrial applications. It

features multi-master operation, message prioritization, error detection, and
fault tolerance, making it ideal for real-time, distributed systems requiring
reliable communication. CAN is commonly used in embedded systems for
applications such as vehicle networking, industrial automation, and distributed
control systems.

1. Question: Explain the concept of serial communication baud rate and its
significance in determining the data transfer rate between devices.
Answer: Baud rate, measured in bits per second (bps), is the rate at which
data is transmitted over a serial communication link. It represents the
number of signal changes (baud) per second and determines the maximum
data transfer rate between devices. A higher baud rate allows for faster
data transmission but requires more precise timing and may be limited by
factors such as cable length and noise immunity. Baud rate must be
configured identically on both transmitting and receiving devices to ensure
proper communication.

2. Question: Describe the process of asynchronous serial communication and

the role of start and stop bits in framing data.
Answer: In asynchronous serial communication, data is transmitted without
a synchronized clock signal, relying instead on the transmission of start and
stop bits to frame each data byte. The start bit indicates the beginning of a
data byte, while the stop bit (or bits) marks the end of the byte and provides
synchronization for the next byte. During transmission, the sender inserts
the start bit before the data byte and one or more stop bits after the data
byte, allowing the receiver to detect the boundaries of each byte and
synchronize its reception.

3. Question: Discuss the advantages and disadvantages of serial

communication over parallel communication in embedded systems.

Embedded interview 12
 Answer: Serial communication offers several advantages over parallel
communication in embedded systems, including simplified wiring, reduced
pin count, longer transmission distances, and better noise immunity.
However, it typically has slower data transfer rates compared to parallel
communication, as data bits are transmitted sequentially instead of
simultaneously. Additionally, serial communication may require additional
hardware for serialization and deserialization, and it may not be suitable for
applications requiring high-speed data transfer or parallel processing.

Bluetooth Low Energy (BLE) and BLE 5.1 Standards:

1. Question: Explain the key features and advantages of Bluetooth Low
Energy (BLE) technology compared to classic Bluetooth, and discuss its
suitability for IoT applications.
Answer: Bluetooth Low Energy (BLE) is a low-power wireless
communication technology designed for short-range communication
between devices with minimal energy consumption. Unlike classic
Bluetooth, BLE operates in short bursts of data transmission, allowing
devices to remain in low-power states for extended periods. BLE is ideal for
IoT applications requiring wireless connectivity, such as smart home
devices, wearable fitness trackers, and asset tracking systems, where long
battery life and intermittent communication are essential.

2. Question: Discuss the role of advertising and scanning in BLE

communication and how they enable device discovery and connection
establishment.
Answer: In BLE communication, advertising involves broadcasting small
packets of data, known as advertisements, at regular intervals to announce
the presence of a device. Scanning refers to the process of actively
listening for advertisements from nearby devices. By scanning for
advertisements, devices can discover and identify nearby BLE peripherals
and establish connections for data exchange. Advertising and scanning
mechanisms enable efficient device discovery and connection
establishment in BLE networks, facilitating seamless interaction between
BLE devices.

3. Question: Describe the concept of BLE services and characteristics and

their role in defining data exchange protocols between BLE devices.

Embedded interview 13
 Answer: In BLE, services and characteristics are used to define data
exchange protocols between devices. A service represents a collection of
related data or functionality, such as heart rate monitoring or temperature
sensing, while characteristics represent specific data points or features
within a service, such as heart rate measurement or temperature value. By
defining services and characteristics, BLE devices establish a standardized
data exchange format, enabling interoperability and compatibility between
different devices and applications.

4. Question: Explain the role of Generic Attribute Profile (GATT) in BLE

communication and its significance in defining data transfer mechanisms
between BLE devices.

Answer: The Generic Attribute Profile (GATT) is a BLE protocol that defines
how BLE devices organize and exchange data using services and
characteristics. GATT specifies a hierarchical data structure consisting of
services, characteristics, and descriptors, enabling BLE devices to
discover, read, write, and notify changes to data values. By adhering to the
GATT specification, BLE devices ensure interoperability and compatibility,
allowing seamless communication and data exchange between different
devices and platforms.

5. Question: Discuss the enhancements introduced in the BLE 5.1 standard

and their impact on IoT applications, particularly in terms of improved
range, direction finding, and indoor positioning.
Answer: BLE 5.1 introduces several enhancements aimed at improving
range, accuracy, and functionality in IoT applications. Key features include
long-range mode, which extends the communication range up to several
hundred meters, direction finding, which enables precise location tracking
and indoor positioning, and improved data transfer rates for faster and more
efficient communication. These enhancements make BLE 5.1 suitable for a
wide range of IoT applications, including asset tracking, indoor navigation,
and smart building systems, where reliable and accurate wireless
connectivity is essential.

Embedded interview 14