Embedded Systems & Digital Circuits

Design a half adder and a full adder circuit from logic gates.

Construct a multi-bit ripple-carry adder and explain its performance limitations.

Design a multiplexer circuit and explain its use as a universal function generator.

Design a decoder circuit and describe its application in memory address selection.

Design an encoder circuit and describe its application in processing multiple input signals.

Apply a standard design procedure to implement a combinational circuit (e.g., a 2-bit comparator) from a word problem.

Distinguish between combinational and sequential circuits, explaining the role of feedback and memory.

Explain the operation of SR, D, and JK latches and flip-flops.

Analyze timing diagrams for sequential circuits including setup and hold time constraints.

Design a shift register and explain its applications (serial-to-parallel conversion, data buffering).

Design an asynchronous (ripple) counter and a synchronous counter circuit.

Derive a state transition table and state diagram for a given sequential circuit.

Construct Moore and Mealy finite state machines from a problem description.

Describe the high-level IC fabrication process (lithography, etching, doping, packaging).

Identify the pinout and function of each pin for a given IC from its datasheet.

Locate and interpret key DC electrical specifications from a datasheet (absolute maximum ratings, VCC, VIH, VIL, VOH, VOL).

Locate and interpret key AC timing characteristics from a datasheet (propagation delay, setup/hold times).

Calculate the fan-out for a given logic gate using datasheet current specifications.

Calculate the static and dynamic power dissipation of a logic gate using datasheet values.

Compare Von Neumann and Harvard memory architectures and their trade-offs.

Describe the roles of the ALU, control unit, and register file within a CPU.

Trace the fetch-decode-execute instruction cycle for a simple instruction.

Distinguish between RISC and CISC instruction set philosophies.

Explain the purpose of address, data, and control buses in a computer system.

Compare memory technologies: SRAM, DRAM, ROM, Flash, and EEPROM.

Explain the role of the stack and stack pointer in subroutine calls and local variable storage.

Use pointers in C to read from and write to specific memory addresses.

Perform bitwise operations (AND, OR, XOR, shift) to manipulate individual bits in a register.

Define and use structs and bit-fields to model hardware registers in C.

Explain the purpose and correct usage of the 'volatile' keyword in embedded C.

Write C code that interacts with memory-mapped I/O registers for peripheral control.

Use preprocessor directives and macros for hardware abstraction and conditional compilation.

Identify common memory-related pitfalls in embedded C: stack overflow and uninitialized variables.

Distinguish between a microprocessor and a microcontroller in terms of architecture and use cases.

Identify the major internal blocks of a microcontroller: CPU core, Flash, SRAM, and peripherals.

Interpret the memory map of a typical microcontroller to locate registers, RAM, and Flash regions.

Explain the clock system of an MCU including internal oscillators, PLLs, and prescalers.

Describe the reset sources and power-on boot sequence of a microcontroller.

Describe the ARM Cortex-M processor architecture at a high level (core registers, pipeline, operating modes).

Describe the purpose and configuration of a watchdog timer.

Configure a GPIO pin as an input or output by writing to its control registers.

Implement button reading (with pull-up/pull-down resistors) and LED control through GPIO register manipulation.

Explain the operating principle of a hardware timer (clock source, prescaler, counter, auto-reload).

Configure a basic timer to generate a periodic interrupt flag for time-based delays.

Generate a PWM signal using a timer peripheral and control its duty cycle.

Explain the function of an ADC and calculate its resolution and quantization error.

Configure an ADC peripheral and perform a single conversion to read an analog sensor value in C.

Explain the UART protocol, including its data frame structure and baud rate.

Write C code to configure a microcontroller's UART peripheral to transmit and receive characters.

Explain the SPI protocol, including master/slave roles, signaling lines, and clock modes.

Write C code to configure an MCU's SPI peripheral to perform a data exchange with a slave device.

Explain the I2C protocol, including its physical layer (open-drain), signaling, and addressing scheme.

Write C code to perform a data exchange with an I2C peripheral device.

Compare polling and interrupt-driven I/O approaches and their trade-offs.

Describe the interrupt vector table and how the processor dispatches an interrupt.

Write an interrupt service routine (ISR) in C for a GPIO or timer event.

Explain interrupt priority levels and nested interrupt handling on a Cortex-M MCU.

Implement both hardware (RC filter) and software (timer-based) debouncing for a mechanical switch.

Explain race conditions and the need for atomic operations when accessing shared resources.

Describe the core concepts of a real-time operating system (RTOS), including tasks, states, and scheduling.

Explain the purpose of inter-task synchronization using semaphores or mutexes.

Describe common voltage regulation approaches (linear vs. switching regulators) for powering embedded systems.

Explain PCB layout fundamentals for digital circuits: ground planes, decoupling capacitors, and trace routing.

Explain the components of an embedded toolchain (cross-compiler, linker, debugger) and the firmware flashing process.

Use a JTAG/SWD debugger to set breakpoints, step through code, and inspect memory and registers.

Use a logic analyzer to capture and analyze digital signals to diagnose communication interface issues.

Deconstruct a problem statement into functional requirements for an embedded system.

Select appropriate components (MCU, sensors) for given requirements, justifying choices using datasheets.

Create a system block diagram and outline the software architecture for a complete embedded system.