Master of Science in VLSI Design and Embedded Systems
Master of Science in VLSI Design and Embedded Systems
Downloads
Master of Science in VLSI Design and Embedded Systems
Downloads
About this degree
The Master of Science in VLSI Design and Embedded Systems is designed to equip students with advanced knowledge and practical expertise in the design, development, and automation of cutting-edge hardware systems. This program offers a comprehensive curriculum that spans foundational and emerging areas of VLSI design, embedded system development, design verification, low-power architectures, robotics, and design automation. Students will develop a deep understanding of both theoretical principles and industry-driven practices, preparing them to design efficient, reliable, and scalable hardware and embedded solutions. The program places strong emphasis on hands-on learning through simulation-based labs, design projects, and case studies, enabling students to master tools and workflows widely used in the semiconductor and embedded systems industry. Learners will gain proficiency in scripting for design automation, hardware– software integration, system verification, and collaborative version control practices, ensuring they are capable of meeting the demands of modern chip and embedded system design cycles. The degree is tailored for professionals and graduates aspiring to lead innovation in semiconductor design, embedded systems engineering, and automation-driven development. With a focus on flexibility and real-world relevance, the program supports students in balancing professional commitments while advancing their technical expertise. Graduates will be prepared to take on roles such as VLSI design engineer, embedded systems architect, verification engineer, design automation specialist, and robotics engineer, contributing to advancements in industries such as consumer electronics, automotive systems, telecommunications, and industrial automation.
Master of Science in VLSI Design and Embedded Systems
Downloads
What you'll learn
**A. Core Skills (Applicable to All Graduates)**
- Design and implement digital hardware and embedded system components using industry-standard HDLs and programming languages, and simulate, debug and verify designs using professional toolchains.
- Develop and evaluate integrated hardware-software systems through modelling, testing, and validation in real and simulated environments.
- Optimise digital and system-level designs for performance, power efficiency, scalability, and reliability using synthesis, verification, timing analysis and place-and-route techniques.
- Apply scripting, automation, and version control tools (e.g., Python, TCL, Shell, Git) to manage, document and streamline complex design workflows and verification processes.
- Apply applied research methods in VLSI and embedded systems contexts, including problem formulation, literature and standards review, experimental design, data collection, analysis of simulation or prototype results, and technical reporting.
- Plan, manage, and execute complex VLSI or embedded systems projects autonomously, making informed technical decisions, managing time and resources, mitigating design risks, and delivering validated solutions aligned with professional and industry standards. **B. Pathway-Specific Advanced Skills** In addition to the core skills, graduates develop advanced competencies aligned with their chosen elective pathway. **1. VLSI Design & Verification Path** Graduates following this pathway will additionally be able to:
- Design complex RTL architectures and implement advanced digital subsystems for ASIC/FPGA targets.
- Develop and execute structured verification strategies using simulation, testbench development, and assertion-based methodologies.
- Analyse and resolve timing, power, and signal integrity issues in advanced digital designs.
- Apply formal verification and validation techniques to ensure functional correctness and design robustness. **2. Embedded & SoC Systems Path** Graduates following this pathway will additionally be able to:
- Architect and integrate heterogeneous system-on-chip (SoC) platforms combining processors, accelerators, and peripherals.
- Develop low-level firmware and optimise hardware-software co-design for real-time and embedded applications.
- Evaluate system-level trade-offs involving latency, memory hierarchy, power constraints, and communication protocols.
- Implement secure and scalable embedded architectures for industrial or application-specific deployment. **3. Manufacturing, Testing & Physical Design Path** Graduates following this pathway will additionally be able to:
- Apply physical design methodologies including placement, routing, floorplanning, and layout optimisation.
- Perform design-for-test (DFT) implementation and fault coverage analysis.
- Analyse manufacturability constraints, yield optimisation, and reliability considerations in silicon production.
- Evaluate advanced node design challenges, including power integrity, clock distribution, and thermal considerations. The differentiation between core and pathway-specific skills ensures that all graduates meet MQF Level 7 expectations for autonomy, complexity, and applied research competence, while also developing advanced specialist expertise aligned with their chosen technical domain.
Master of Science in VLSI Design and Embedded Systems
Downloads
Course Structure
About
This course** provides learners with the foundational knowledge and applied skills essential for careers in the semiconductor and embedded systems industry. The course integrates theoretical concepts with practical implementation, covering both front-end and back-end VLSI design methodologies. Learners are introduced to VLSI design principles, ASIC and FPGA workflows, and industry-standard verification processes. Building on digital logic fundamentals, the course incorporates the RISC-V Instruction Set Architecture, guiding students toward the Register Transfer Level (RTL) design and implementation of a pipelined RISC-V processor. In addition, learners explore CMOS basics, full-custom ASIC design strategies, and critical timing concepts. By connecting digital electronics theory with practical applications, the course enables students to design systems that are functionally correct, synthesizable, and optimized for performance and resource efficiency.
Teachers
Intended learning outcomes
- Apply CMOS and PDK rule-based constraints in basic layout exercises.
- Describe the architecture and instruction set principles of RISC-V and its role in processor design.
- Explain the fundamental concepts of VLSI design, including ASIC and FPGA design flows.
- Analyze CMOS fundamentals and timing concepts relevant to full-custom ASIC design.
- Develop RTL-level models of a pipelined RISC-V processor using a hardware description language.
- Simulate and test VLSI designs to evaluate functional correctness, synthesizability, and performance trade-offs.
- Apply digital logic principles to design and verify combinational and sequential circuits.
- Integrate theoretical VLSI concepts with practical workflows to design optimized digital systems for performance and area.
- Collaborate in virtual design environments to solve VLSI implementation challenges using industry-standard tools.
- Demonstrate the ability to critically assess and refine VLSI designs in alignment with professional standards of the semiconductor industry.
About
This course provides a structured introduction to the Verilog Hardware Description Language (HDL), equipping learners with the ability to model, simulate, and design digital systems at the RTL level. The course begins with the fundamentals of Verilog, including modules, data types, procedural and continuous assignments, as well as behavioral and structural modeling. Learners will gain practical experience in hardware design environments through the use of Linux commands and the VI editor. Building on this foundation, the course advances to complex Verilog concepts such as tasks, functions, synthesizable constructs, and testbench development, with a strong emphasis on writing modular, reusable, and efficient code. Finally, learners are introduced to code coverage techniques, enabling them to evaluate verification quality and completeness effectively.
Teachers
Intended learning outcomes
- Design RTL blocks following IEEE 1800-compliant coding guidelines.
- Explain the core constructs of Verilog, including modules, assignments, and modeling techniques.
- Differentiate between behavioral, structural, and RTL-level descriptions in Verilog.
- Summarize advanced Verilog concepts such as synthesizable constructs, tasks, functions, and code coverage methods.
- Develop and execute testbenches to verify digital system functionality and assess correctness.
- Use Linux commands and the VI editor effectively to manage Verilog-based design projects in a typical hardware design environment.
- Write Verilog code to model and simulate combinational and sequential circuits at the RTL level.
- Demonstrate professional coding practices by adhering to industry standards for clarity, modularity, and reusability in hardware design.
- Integrate advanced Verilog features to design scalable, reusable, and synthesizable RTL code.
- Evaluate verification completeness using code coverage metrics and refine test strategies accordingly.
About
This course lays the foundation for developing and debugging modern embedded systems. The course begins with hardware system interfacing fundamentals and introduces learners to microprocessors and microcontrollers, with platforms such as STMicroelectronics serving as examples. Emphasis is placed on embedded C programming for system-level applications. Learners also gain exposure to the ARM Instruction Set Architecture (ISA) and supporting toolchains, while exploring key quality attributes of embedded systems. Additionally, the course introduces debug interfaces and debuggers such as SWD and JTAG, providing practical insight into low-level programming, system control, and debugging practices essential for embedded system development.
Teachers
Intended learning outcomes
- Describe the ARM Instruction Set Architecture (ISA) and associated toolchains used in embedded system development.
- Explain the fundamentals of embedded system architecture, including microprocessors, microcontrollers, and hardware interfacing.
- Analyze the quality attributes of embedded systems, such as reliability, efficiency, and scalability.
- Interpret instruction-set specifications (RISC-V/ARM) in program design.
- Use debugging tools (e.g., SWD, JTAG) to identify and resolve errors in embedded systems.
- Implement basic system interfacing techniques to integrate hardware components with microcontrollers.
- Write embedded C programs for microcontroller-based applications.
- Demonstrate professional proficiency in low-level programming and system control for embedded applications aligned with real-world design standards.
- Integrate microcontroller platforms, embedded C, and debugging techniques to develop functional embedded applications.
- Evaluate embedded systems for performance and quality, applying industry-relevant metrics and debugging practices.
About
This course builds on foundational concepts to provide learners with a comprehensive understanding of embedded peripheral interfaces from a programmer’s perspective. The course explores the internal functionality and software-level integration of analog and digital peripherals, such as ADCs, DACs, sensors, buttons, LEDs, LCDs, and other input/output devices, using microcontroller platforms. Learners will gain practical experience in controlling and interfacing peripherals through embedded programming.
In addition, the course introduces the fundamentals of embedded networking, covering widely used communication stacks and protocols including TCP/IP and UDP. Emphasis is placed on the layered architecture of networking stacks, packet structures, socket programming, and applications in IoT and embedded systems. Through applied programming exercises and lab-based activities, learners will acquire hands-on skills in peripheral integration and implementing network communication protocols for real-world embedded applications.
Teachers
Intended learning outcomes
- Explain the principles of analog and digital peripheral interfacing, including ADCs, DACs, input devices, and display systems.
- Describe the layered architecture of networking stacks, packet structures, and common embedded communication protocols such as TCP/IP and UDP.
- Explain functional safety principles (ISO 26262) in embedded applications.
- Analyze the role of peripheral devices and communication stacks in the functionality and performance of embedded systems.
- Write embedded programs to control and interface analog and digital peripherals with microcontrollers.
- Implement socket programming and communication protocols to enable data exchange in embedded systems.
- Simulate and test embedded applications that integrate peripherals and networking protocols for correctness and efficiency.
- Integrate multiple peripheral devices with microcontrollers to design functional embedded applications.
- Demonstrate professional proficiency in designing and debugging embedded systems that combine peripheral interfacing and network communication.
- Evaluate embedded networking solutions for IoT and real-time applications, considering performance, scalability, and reliability.
About
This course introduces learners to the architecture, design methodologies, and communication protocols central to modern System-on-Chip (SoC) development. The course begins with a detailed study of SoC architecture, emphasizing the integration of processing cores, memory subsystems, and hardware accelerators. Learners will gain an understanding of the complete SoC design flow, including specification, IP integration, simulation, synthesis, verification, and physical design. The course highlights interconnect protocols such as AXI, AHB, and APB, exploring how bridges and bus fabrics enable seamless communication between IP blocks. Additionally, students will examine processor–peripheral communication through protocols like I²C, SPI, UART, and GPIO, while also being introduced to wireless communication standards such as Wi-Fi and Bluetooth. Special focus is placed on their architectures, stack layers, and the integration challenges encountered in SoC design.
Teachers
Intended learning outcomes
- Describe the stages of the SoC design flow, from specification through physical design.
- Use AMBA/TileLink protocol specifications to construct SoC block diagrams.
- Explain the fundamental components of SoC architecture, including processing cores, memory systems, and hardware accelerators.
- Analyze the role of interconnect and communication protocols (AXI, AHB, APB, I²C, SPI, UART, GPIO, Wi-Fi, Bluetooth) in enabling efficient SoC integration.
- Develop simulations to evaluate IP integration and protocol-level communication within SoC subsystems.
- Use design and verification tools to test SoC components for functionality and protocol compliance.
- Apply SoC interconnect protocols to design simple processor–peripheral communication models.
- Evaluate processor–peripheral and wireless communication implementations for efficiency, scalability, and integration challenges.
- Integrate IP blocks, memory, and peripheral interfaces into a simplified SoC design using industry-relevant methodologies.
- Demonstrate the ability to design and refine SoC architectures that align with real-world performance, interoperability, and communication standards.
About
This course introduces learners to the fundamental and performance-driven principles of modern computer systems. The course begins with an exploration of processor instruction set architectures (ISAs), covering both RISC and CISC paradigms, as well as system-level models such as Von Neumann and Harvard architectures. Learners study essential components, including address, data, and control buses, interrupt controllers, and Direct Memory Access (DMA), alongside the fundamentals of memory organization. The course then covers virtual memory concepts such as address translation, page tables, and Translation Lookaside Buffers (TLBs). Building on this foundation, learners engage with high-performance design techniques, including instruction pipelining, address pipelining, and parallel processing. A dedicated unit on cache architecture provides an in-depth understanding of the memory hierarchy, cache mapping methods, replacement and write policies, and coherence protocols, including an introduction to the Cache Coherent Interconnect for Accelerators (CHI). By connecting theory with real-world processor design practices, the course equips students with insights into how modern systems achieve efficiency, scalability, and performance.
Teachers
Intended learning outcomes
- Describe the role of buses, interrupt controllers, DMA, and memory organization in computer architecture.
- Apply IEEE 754 FP behaviour in datapath design exercises.
- Explain the principles of processor instruction set architectures (RISC and CISC) and system-level models.
- Analyze cache design principles, including mapping, replacement policies, and coherence protocols such as CHI.
- Implement basic models of instruction pipelining and parallel execution in a simulated processor environment.
- Simulate and test cache behavior under different mapping and replacement policies to assess performance trade-offs.
- Illustrate the process of virtual memory translation using page tables and TLBs through examples or simulations.
- Evaluate architectural trade-offs between performance, efficiency, and scalability in processor design.
- Integrate concepts of ISAs, pipelining, memory systems, and cache design into a simplified processor model.
- Demonstrate professional-level understanding by applying architectural concepts to real-world case studies of modern high-performance processors.
About
This course offers an advanced study of the RISC-V architecture, with a focus on system-level design and specialized extensions. Learners will develop a detailed understanding of privilege modes, memory protection, exception and interrupt handling, and system programming within RISC-V. Emphasis is placed on practical engagement with RISC-V toolchains, debugging methods, and application development for both embedded and general-purpose platforms. The course also introduces key ISA specifications such as PLIC, Debug, and Trace, alongside support for extensions including vector, atomic, floating-point, bit manipulation, and custom ISAs. By the end of the course, students will be equipped to leverage the flexibility of the open RISC-V ecosystem to design high-performance and domain-specific applications. This course also explores contemporary processor architectures with emphasis on hardware virtualisation support, throughput-oriented GPU designs, and heterogeneous computing paradigms. Learners critically evaluate hypervisor-aware architectures, GPU scheduling mechanisms, and advanced memory hierarchies using real-world architectural examples.
Teachers
Intended learning outcomes
- Identify and describe the role of ISA specifications such as PLIC, Debug, and Trace in system design.
- Explain RISC-V privilege modes, memory protection mechanisms, and system-level programming concepts.
- Discuss the purpose and functionality of advanced ISA extensions, including vector, atomic, floating-point, and bit manipulation instructions.
- Demonstrate the integration of RISC-V ISA extensions to optimize performance in application development.
- Apply RISC-V software toolchains to write, compile, and debug system-level programs.
- Implement exception and interrupt handling routines in RISC-V through coding and simulation exercises.
- Design and justify custom ISA extensions to address specific application or domain requirements within the RISC-V ecosystem.
- Critically assess advanced processor architectures supporting virtualisation, GPU-based parallelism, and heterogeneous computing, making informed architectural trade-offs based on performance and scalability constraints.
- Evaluate system design trade-offs when selecting RISC-V ISA extensions for high-performance and domain-specific applications.
- Integrate advanced RISC-V architectural features into embedded or general-purpose system workflows.
About
This course provides an in-depth exploration of advanced embedded system design, integrating both hardware and software perspectives. Learners will engage with embedded Linux programming, real-time operating system concepts, and security mechanisms for modern embedded platforms. The course introduces advanced processor architectures, hardware/software co-design methodologies, and parallel computing techniques to support the development of efficient, secure, and high-performance solutions. Practical application is emphasized through Linux-based environments and FPGA-based implementations, enabling learners to connect theoretical foundations with real-world embedded system applications.
Teachers
Intended learning outcomes
- Summarize advanced processor architectures, hardware/software co-design, and parallel computing strategies relevant to embedded systems.
- Explain the principles of embedded Linux programming and its role in system-level development.
- Apply MISRA-C and safety guidelines in embedded firmware.
- Describe real-time system design requirements and constraints for embedded platforms.
- Design an embedded system prototype (conceptual or simulation-based) that demonstrates the application of Linux programming, real-time features, and performance optimization.
- Integrate hardware and software components to design efficient embedded solutions for real-world applications
- Evaluate security considerations in embedded system design and propose methods to mitigate vulnerabilities.
- Analyze the impact of parallel computing approaches on the performance of embedded systems.
- Develop basic embedded applications using Linux-based programming environments.
- Implement real-time scheduling and synchronization mechanisms in simulated embedded contexts.
About
This course provides learners with the expertise to design and implement intelligent embedded solutions for edge and IoT environments. Starting with core principles of IoT and embedded machine learning, students advance to understanding industrial communication protocols, edge device orchestration, and secure data management. The curriculum emphasizes real-time AI inferencing, optimization of embedded models, and applications of generative AI in IoT and SoC workflows. With a strong hands-on approach, the course prepares engineers to create secure, scalable, and high-performance AI-driven embedded systems for edge computing.
Teachers
Intended learning outcomes
- Describe industrial communication protocols and their role in IoT and edge computing environments.
- Explain the foundational concepts of IoT architectures and embedded machine learning.
- Summarize methods of secure data handling, embedded model optimization, and real-time AI inferencing in edge devices.
- Apply embedded machine learning models to perform AI inferencing tasks on edge devices.
- Optimize pre-trained AI models for deployment in resource-constrained embedded platforms.
- Implement basic IoT workflows integrating industrial protocols in a simulated environment.
- Design a prototype (conceptual or simulation-based) of an intelligent embedded AI system for IoT/SoC workflows that demonstrates real-time inferencing and system orchestration.
- Evaluate security, scalability, and performance trade-offs in designing intelligent edge and IoT systems.
- Integrate embedded ML, industrial protocols, and secure data handling into an end-to-end IoT solution.
About
This course emphasizes the application of embedded systems across specialized domains such as robotics, automotive, healthcare, and RF technologies. Learners will engage with advanced topics including autonomous navigation for robotic platforms, RFIC and PCB-based system design, and the development of medical-grade embedded devices aligned with regulatory standards. The curriculum integrates advanced perception, signal integrity, cryptographic security, and system assurance to support the creation of robust, domain-specific embedded applications. Through real-world case studies and practical projects, students gain the expertise to address industry challenges and drive innovation in embedded product design and deployment. The course also explores embedded system design for AI-enabled applications, focusing on integration of NPUs and accelerator-centric processing pipelines. Learners evaluate accelerator dataflows, memory hierarchies, and HW–SW coordination in real-time embedded AI systems.
Teachers
Intended learning outcomes
- Describe principles of RFIC/PCB design, medical device compliance, and system assurance in embedded environments.
- Discuss advanced perception, signal integrity, and cryptographic security techniques for reliable embedded solutions.
- Explain domain-specific requirements of embedded systems in robotics, automotive, healthcare, and RF applications.
- Implement security mechanisms and system integrity checks in embedded prototypes using case-study scenarios.
- Demonstrate basic RF system design or PCB-level integration in a simulated toolchain.
- Apply autonomous navigation algorithms to simulated robotic or vehicular platforms.
- Evaluate embedded solutions for compliance, safety, and performance across healthcare, robotics, and automotive domains.
- Design a domain-driven embedded system prototype (simulation or project-based) addressing real-world constraints such as safety, compliance, and robustness.
- Demonstrate responsibility for deploying and validating embedded systems on FPGA or equivalent prototyping platforms, ensuring correct functionality under real-time constraints
- Evaluate and integrate NPU-based accelerator subsystems within embedded platforms, considering real-time constraints, memory hierarchies, and HW–SW coordination.
- Exercise professional judgement in balancing timing, power, and resource constraints during embedded system implementation and testing.
- Integrate perception, signal integrity, and cryptographic methods into a domain-specific embedded application design.
About
This course offers an in-depth introduction to the hardware foundations of modern electronics, focusing on Printed Circuit Board (PCB) design, semiconductor device physics, and wafer manufacturing processes. Learners will gain insights into PCB design workflows, including schematic capture, component placement, routing, and design rule checks, with particular attention to signal integrity and manufacturability. The course also examines the behavior and modeling of essential semiconductor devices such as diodes, BJTs, and MOSFETs, which underpin both analog and digital circuit design. Furthermore, it introduces the semiconductor fabrication process, covering wafer preparation, photolithography, doping, etching, and packaging techniques. By integrating these perspectives, students will develop a foundational understanding of how electronic systems are designed and realized—from raw silicon to complete board-level implementation.
Teachers
Intended learning outcomes
- Describe the fundamental behavior and modeling of semiconductor devices such as diodes, BJTs, and MOSFETs.
- Interpret JEDEC packaging standards in process-flow assessments.
- Summarize the steps involved in wafer fabrication, including photolithography, doping, etching, and packaging.
- Explain the principles of PCB design, including schematic capture, placement, routing, and design rule verification.
- Demonstrate the sequence of wafer fabrication steps through case-based or simulation-based exercises.
- Apply PCB design workflows using simulation or design software to ensure signal integrity and manufacturability.
- Analyze the electrical characteristics of semiconductor devices and evaluate their role in circuit performance.
- Design a simple PCB or circuit module, incorporating device characteristics and fabrication constraints, and justify the design decisions.
- Evaluate PCB design choices to balance manufacturability, performance, and signal integrity trade-offs.
- Integrate knowledge of semiconductor device physics and fabrication processes to explain how circuits transition from raw silicon to packaged devices.
About
This course provides a comprehensive exploration of the post-silicon phase of semiconductor development, emphasizing Packaging Design, Package Assembly, and IC Testing. Learners will examine the principles and design methodologies used in semiconductor packaging, with a focus on optimizing thermal, mechanical, and electrical performance. The course further introduces key assembly processes, including die attach, wire bonding, flip-chip technology, and encapsulation, highlighting issues of reliability and manufacturability. In addition, students will study integrated circuit (IC) testing approaches, such as wafer-level and package-level testing, test coverage evaluation, and defect detection methods. By integrating these elements, the course equips learners with the expertise to connect silicon fabrication with system-level deployment, ensuring robust and reliable chip production.
Teachers
Intended learning outcomes
- Explain the principles of semiconductor packaging design, considering thermal, mechanical, and electrical requirements.
- Summarize IC testing methodologies, including wafer-level and package-level testing, and their role in quality assurance.
- Describe the major IC assembly techniques, including die attach, wire bonding, flip-chip, and encapsulation.
- Apply design considerations to evaluate package types for different performance and reliability requirements.
- Demonstrate understanding of package assembly workflows through simulation, case studies, or virtual labs.
- Analyze IC test results and identify common manufacturing defects or performance limitations.
- Design a package-testing strategy for a given semiconductor device, justifying the approach in terms of coverage, defect detection, and system-level reliability.
- Integrate knowledge of packaging, assembly, and testing to propose solutions for real-world chip deployment challenges.
- Evaluate trade-offs in packaging design decisions with respect to manufacturability, reliability, and performance.
About
This course provides learners with a deep understanding of emerging innovations in System-on-Chip architectures, with a particular focus on multi-die and chiplet-based systems. The course begins with an overview of Systems of Chips, chiplets, and advanced integration techniques, emphasizing the industry transition from monolithic designs to modular and scalable architectures. A central theme is the Universal Chiplet Interconnect Express (UCIe), a new standard enabling seamless, high-bandwidth die-to-die communication across heterogeneous components. Learners will also engage with a case study on RISC-V SoC design, exploring open-source hardware concepts, subsystem integration, and real-world design flows. This applied component reinforces architectural principles while highlighting practical industry practices. By the end of the course, students will be equipped with advanced knowledge of SoC design concepts, interconnect protocols, and multi-die integration strategies, preparing them for roles in silicon design, system architecture, and semiconductor product development. This course also focuses on advanced SoC architectures incorporating hardware virtualisation, AI accelerators, and hardware–software co-design methodologies. Learners design and evaluate simplified accelerator blocks within SoC pipelines, analysing performance, memory access, and HW–SW interaction for AI workloads.
Teachers
Intended learning outcomes
- Explain the principles of multi-die and chiplet-based architectures, contrasting them with monolithic SoC designs.
- Describe the UCIe standard and its role in enabling die-to-die communication across heterogeneous components.
- Validate interconnect compliance with AMBA AXI specifications.
- Analyze open-source RISC-V SoC architectures and subsystems within the context of modern design flows.
- Develop design experiments or simulations to evaluate UCIe-based die-to-die interconnect performance.
- Apply SoC integration methodologies to model modular chiplet-based systems.
- Implement subsystem integration in a RISC-V SoC design flow using open-source design tools.
- Design and justify accelerator-integrated SoC pipelines, assessing hardware–software interactions and performance trade-offs in AI-oriented workloads.
- Lead and manage iterative and agile hardware development cycles for complex SoC designs, coordinating collaborative tasks, integrating IP blocks, and making informed trade-offs across performance, power, area, and cost constraints.
- Demonstrate the ability to apply advanced SoC design principles and open-source methodologies to real-world system architecture challenges.
- Demonstrate autonomy in selecting appropriate prototyping, verification, and integration strategies, including FPGA-based validation and collaborative version-controlled workflows.
- Integrate chiplet-based components and interconnect standards to design scalable multi-die SoC systems.
- Evaluate trade-offs in SoC architectures with respect to performance, scalability, cost, and manufacturability in advanced semiconductor products.
About
This course provides an in-depth study of front-end design challenges and solutions in advanced digital systems, with emphasis on Clock Domain Crossing (CDC), Reset Domain Crossing (RDC), low-power design methodologies, and RTL signoff techniques. Learners will explore methods to identify and resolve CDC and RDC issues for robust data transfer across asynchronous domains. The course also examines low-power design strategies, such as clock gating, power gating, multi-voltage operation, and UPF-based power intent specification. In addition, students will gain hands-on experience with RTL linting, logic synthesis, and formal equivalence checking, ensuring that RTL designs are functionally accurate, optimized, and ready for physical implementation. Through a mix of theoretical concepts and tool-driven labs, learners will build the ability to address design quality, power efficiency, and correctness in complex SoC and ASIC development.
Teachers
Intended learning outcomes
- Apply UPF/CPF specifications in low-power design flows
- Describe low-power design methodologies, including clock gating, power gating, and UPF-based specifications.
- Outline the principles of RTL signoff processes such as linting, logic synthesis, and equivalence checking.
- Explain the concepts of CDC and RDC, and their impact on digital system reliability
- Implement low-power design strategies in RTL using UPF specifications and power optimization methods.
- Apply CDC and RDC verification techniques using EDA tools to detect and resolve domain-crossing issues.
- Perform RTL linting, synthesis, and formal equivalence checks to validate design readiness for physical implementation.
- Design and justify a verified RTL module or subsystem that demonstrates reliable asynchronous communication, power optimization, and functional correctness.
- Evaluate design choices for robustness, low-power efficiency, and correctness in advanced SoC and ASIC development.
- Integrate CDC/RDC solutions, low-power design techniques, and RTL signoff practices into a cohesive front-end design flow.
About
This course offers an in-depth exploration of FPGA-based digital system design, starting with the fundamentals and progressing to advanced implementation techniques. Learners will study FPGA architectures, design flows, and hardware description languages (Verilog/VHDL) to model and realize digital circuits on reconfigurable hardware. The curriculum extends to advanced topics such as IP integration, high-speed interfaces, clocking strategies, and design optimization with respect to performance, power, and area. Students will also engage with specialized FPGA features, including embedded processors, DSP blocks, and high-level synthesis (HLS) for design acceleration. Through hands-on labs and project-based activities, participants will acquire practical expertise in developing, verifying, and deploying complex FPGA-based designs, preparing them for applications in prototyping, embedded systems, and hardware acceleration.
Teachers
Intended learning outcomes
- Explain the architecture, design flow, and hardware description approaches (Verilog/VHDL) used in FPGA-based systems.
- Identify design trade-offs in performance, area, and power for FPGA implementations.
- Describe advanced FPGA capabilities, including embedded processors, DSP blocks, and HLS methodologies.
- Apply IP integration, clocking strategies, and high-speed interface design in FPGA projects.
- Use FPGA design tools to perform synthesis, simulation, and optimization for area, performance, and power.
- Develop digital circuits in Verilog or VHDL and implement them on FPGA platforms.
- Evaluate FPGA design solutions for efficiency, scalability, and suitability in real-world applications such as prototyping or embedded systems.
- Integrate advanced FPGA features (DSP blocks, embedded processors, HLS) into functional system-level designs.
- Design and justify a complete FPGA-based project that demonstrates correct functionality, optimization, and deployment readiness.
About
This course provides a comprehensive study of Analog and Mixed-Signal (AMS) Integrated Circuit (IC) Design, combining theoretical foundations with advanced design and verification methodologies. Beginning with core circuit theory to establish analytical rigor, students will design essential analog building blocks such as current mirrors, differential amplifiers, and operational amplifiers. The course advances into specialized topics including biasing strategies, frequency compensation, noise analysis, and low-power/low-voltage design techniques. Learners will also develop expertise in AMS behavioral modeling and verification, applying high-level abstractions to model analog behavior and validate mixed-signal systems. Through a blend of theoretical analysis, simulations, and project-based labs, students will gain the ability to design, analyze, and verify complex AMS circuits, preparing them for applications in communication, sensing, and power management systems.
This module also addresses advanced digital design techniques for high-throughput computing, including GPU-inspired parallel architectures. Students analyse SIMT processing elements, warp scheduling concepts, and throughput-driven VLSI design strategies through design-oriented exercises.
Teachers
Intended learning outcomes
- Explain fundamental circuit theory concepts as they apply to analog and AMS IC design.
- Describe the operation and characteristics of analog building blocks such as current mirrors, differential amplifiers, and op-amps.
- Summarize advanced analog design considerations, including biasing, frequency compensation, noise analysis, and low-power/low-voltage techniques.
- Apply techniques for frequency compensation, biasing, and noise analysis in analog and mixed-signal circuits.
- Analyse and implement throughput-oriented digital design techniques inspired by GPU architectures, including SIMT execution and parallel scheduling concepts.
- Use AMS behavioral modeling to simulate and verify the performance of mixed-signal systems.
- Design analog circuits (e.g., current mirrors, differential amplifiers, op-amps) using simulation tools.
- Design and justify a complete AMS project that demonstrates robust design methodology, simulation-based verification, and system-level applicability.
- Integrate analog building blocks into mixed-signal architectures for applications in communication, sensing, and power management.
- Evaluate analog and AMS circuit designs for trade-offs involving power, performance, and noise.
About
This course introduces students to advanced verification and debugging techniques within the digital design flow, with a particular emphasis on Gate-Level Simulation (GLS) and the Universal Verification Methodology (UVM). Learners will explore the role of GLS in validating post-synthesis and post-place-and-route netlists, focusing on critical issues such as timing accuracy, glitches, and X-propagation. The course further provides a comprehensive overview of UVM, an industry-standard framework for developing reusable, modular, and scalable verification environments in SystemVerilog. Key topics include transaction-level modeling, sequences, drivers, monitors, and scoreboards, along with portable stimulus generation demonstrated through a case study. Through practical labs and simulation-based exercises, students will gain hands-on experience in debugging gate-level designs and constructing structured verification environments for complex SoC implementations.
Teachers
Intended learning outcomes
- Describe the components and principles of the Universal Verification Methodology (UVM).
- Summarize common verification challenges such as timing issues, glitches, and X-propagation in GLS.
- Explain the purpose and workflow of gate-level simulation in digital design verification.
- Apply transaction-level modeling and portable stimulus techniques in verification scenarios.
- Perform gate-level simulations to validate post-synthesis and post-layout netlists using EDA tools.
- Construct modular testbenches in SystemVerilog using UVM concepts such as drivers, monitors, and scoreboards
- Design and justify a complete verification project that demonstrates debugging proficiency and UVM-based environment development.
- Integrate UVM components into structured, reusable verification environments for SoC designs.
- Evaluate GLS results to identify and resolve issues related to timing, glitches, and X-propagation.
About
This course delves into power-aware verification methodologies that are crucial for developing modern, energy-efficient integrated circuits. With power efficiency now a key requirement in applications such as mobile devices and IoT systems, this course emphasizes the importance of verifying low-power intent across different stages of the design cycle. Learners will study the IEEE 1801 Unified Power Format (UPF), which defines power management intent separately from RTL design. Key topics include the fundamentals of UPF-based design and verification—covering power domain creation, isolation techniques, level shifting, retention mechanisms, and power state tables. The course also highlights how UPF integrates into simulation and verification workflows to accurately model power intent and detect functional issues such as missing retention or faulty isolation. Through guided labs and hands-on exercises, participants will learn to set up UPF verification environments, conduct power-aware checks, and validate designs under various power conditions. By the end of the course, students will be equipped to analyze, detect, and resolve low-power design issues, ensuring functional correctness in complex, low-energy VLSI systems.
Teachers
Intended learning outcomes
- Describe the role of the IEEE 1801 Unified Power Format (UPF) in specifying power intent independent of RTL.
- Differentiate between power management techniques such as isolation, retention, and level shifting in UPF-based verification
- Explain the principles of power-aware verification and its significance in modern low-power VLSI design.
- Apply UPF concepts to define power domains, isolation strategies, and power state tables for given design scenarios.
- Debug low-power design issues such as missing retention or incorrect isolation through simulation-based case studies.
- Implement power-aware verification checks within simulation workflows to validate power intent.
- Integrate UPF methodologies into SoC verification flows to ensure scalability and accuracy in power-aware simulations.
- Propose optimized verification strategies to address energy-efficiency challenges in advanced VLSI designs.
- Evaluate design correctness under multiple power scenarios using UPF-based verification environments
About
This course offers an in-depth study of digital design implementation and testing methodologies, blending theoretical concepts with practical training on industry-standard Synopsys tools. It begins with RTL linting to detect coding errors, design rule violations, and structural issues early in the design cycle. Students will then perform RTL synthesis, applying design constraints and incremental optimizations following DFT (Design for Test) insertion. The course also emphasizes formal equivalence checking to ensure functional correctness between RTL and synthesized netlists. In the testing domain, learners will study and apply advanced techniques such as LBIST (Logic Built-In Self-Test), MBIST (Memory Built-In Self-Test), and test compression methods to enhance in-system testing efficiency and reduce test overhead. Through guided labs, students will gain hands-on experience in preparing robust, testable, and silicon-ready designs.
Teachers
Intended learning outcomes
- Describe the process of RTL synthesis, including constraint handling and incremental optimization post-DFT insertion.
- Explain the principles of RTL linting and its role in identifying coding and structural issues in digital designs.
- Discuss advanced test methodologies such as LBIST, MBIST, and test compression and their importance in VLSI design.
- Apply RTL linting techniques to detect and resolve common coding and design rule violations using Synopsys tools.
- Perform RTL synthesis with design constraints and incremental optimizations to generate optimized, testable netlists.
- Implement formal equivalence checking to validate functional consistency between RTL and synthesized netlists.
- Evaluate and deliver fully testable designs, demonstrating readiness for silicon implementation through lab-based verification projects.
- Develop efficient test compression strategies that minimize pattern volume and reduce test execution time.
- Integrate LBIST and MBIST strategies to enhance the reliability of digital systems under real-world conditions
About
This course delves into advanced Design-for-Testability (DFT) strategies tailored for low-power and complex SoC architectures. It emphasizes power-aware testing techniques to address challenges such as multi-power domains, power gating, and clock gating, ensuring efficient testability while maintaining high fault coverage. The course also introduces the IEEE 1687 (IJTAG) standard, which provides a scalable approach to accessing embedded instruments within SoC IP blocks. Students will gain hands-on experience in integrating IJTAG into SoC test infrastructures, enabling modular and reusable test solutions. Through a blend of theory and practical labs, learners will develop the ability to implement robust, power-aware, and standards-compliant DFT methodologies for modern SoC designs.
Teachers
Intended learning outcomes
- Analyze the impact of power-aware test techniques on fault coverage and SoC performance.
- Describe the role and structure of IEEE 1687 (IJTAG) in enabling efficient test access for embedded instruments.
- Explain the principles of low-power DFT strategies, including power gating, multi-domain testing, and clock gating.
- Demonstrate the use of IJTAG for configuring and accessing embedded instruments in SoC IP blocks.
- Apply low-power DFT methodologies to verify designs with multiple power domains in a simulated environment.
- Implement test flows that integrate power-aware strategies while optimizing test coverage and runtime.
- Evaluate trade-offs between power efficiency, test coverage, and test time when applying advanced DFT techniques.
- Critically assess and justify DFT methodologies for complex low-power SoCs in terms of industry compliance and practical feasibility.
- Design a scalable, reusable test infrastructure for SoC designs using IJTAG principles.
About
This course provides an in-depth understanding of advanced Static Timing Analysis (STA) and Physical Verification processes essential for ensuring both the functional accuracy and physical integrity of digital IC designs. Learners will study advanced STA concepts, including multi-mode multi-corner (MMMC) analysis, timing exceptions, clock domain crossing (CDC) verification, and techniques for managing on-chip variation (OCV). The course further explores critical Physical Verification steps such as Design Rule Checking (DRC), Layout Versus Schematic (LVS), Antenna Rule checks, and Electrostatic Discharge (ESD) compliance, leading to complete sign-off readiness. Emphasis is placed on applying industry-standard methodologies and EDA tool flows for achieving timing closure and manufacturability. Hands-on labs and case studies provide practical exposure to timing closure strategies, physical verification, and sign-off preparation, enabling students to confidently prepare designs for successful tape-out.
Teachers
Intended learning outcomes
- Differentiate between functional verification and sign-off processes, emphasizing their roles in achieving design closure and manufacturability.
- Explain advanced STA principles such as MMMC analysis, timing exceptions, and OCV handling in the context of VLSI design.
- Describe the purpose and methodology of physical verification steps including DRC, LVS, Antenna checks, and ESD compliance.
- Apply MMMC analysis techniques to evaluate timing performance across different operating conditions using industry-standard tools.
- Demonstrate the use of EDA workflows to implement timing closure strategies and prepare a design for sign-off readiness.
- Perform physical verification tasks such as DRC and LVS checks to identify and resolve design rule violations in IC layouts.
- Integrate STA and physical verification methodologies into a comprehensive flow that ensures both functional correctness and manufacturability.
- Develop sign-off-ready design reports that effectively communicate timing closure results, verification outcomes, and tape-out readiness for professional review.
- Evaluate design trade-offs and propose solutions to timing and physical verification challenges in complex digital IC designs.
About
This course delves into advanced practices in digital IC implementation, with emphasis on power-aware physical design, AI-driven optimization, logic equivalence checking, and signal integrity analysis. Students will study methods to reduce both dynamic and static power during placement, routing, and clock tree synthesis, while integrating power intent specifications and multi-voltage domain design. The curriculum also highlights emerging AI/ML-based approaches for placement, congestion prediction, and timing closure, improving both productivity and design quality. A dedicated module on logic equivalence checking ensures functional alignment across design stages, from RTL through gate-level representations. Furthermore, learners will investigate signal integrity challenges such as crosstalk, noise, and delay variations, and apply corrective measures during physical design. Through hands-on labs and real-world case studies, students will acquire practical expertise in building high-performance, low-power chips using modern, intelligent design methodologies.
Teachers
Intended learning outcomes
- Explain techniques for reducing dynamic and static power in placement, routing, and clock tree synthesis.
- Describe AI/ML-based methodologies applied to placement optimization, congestion prediction, and timing closure.
- Summarize the principles of logic equivalence checking and signal integrity analysis in advanced physical design.
- Demonstrate the use of AI/ML-assisted tools to optimize design quality and productivity during IC implementation.
- Apply power intent specifications and multi-voltage domain strategies in a physical design flow.
- Perform signal integrity analysis (crosstalk, noise, delay variations) and propose suitable mitigation strategies.
- Evaluate the effectiveness of AI-driven optimization techniques in addressing timing closure challenges for complex SoCs.
- Integrate power-aware design methodologies with logic equivalence checking to ensure consistency across design transformations.
- Design a power-efficient, high-performance chip implementation flow that balances power, performance, and signal integrity trade-offs.
About
This course offers an in-depth study of two major processor architectures: ARM and RISC-V. It begins with the core principles of reduced instruction set computing (RISC), providing students with a solid understanding of their architectural foundations, instruction sets, and pipeline structures. Learners will then explore ARM-specific features, including software interfaces, exception handling, and peripheral programming, reinforced through practical coding exercises. The course advances into topics such as ARM TrustZone, memory protection units, and performance monitoring, highlighting security and optimization techniques. Alongside, comparative discussions of ARM and RISC-V design philosophies and ecosystem support prepare learners for embedded system development and System-on-Chip (SoC)-level integration using both architectures. This module also introduces advanced architectural features including low-level hardware virtualisation mechanisms, GPU execution models, and vector processing extensions. Students analyse MMU/IOMMU support, SIMT-based GPU architectures, and RISC-V Vector Extensions through comparative architectural case studies.
Teachers
Intended learning outcomes
- Describe advanced ARM features such as TrustZone, memory protection units, and performance monitoring in the context of security and efficiency.
- Differentiate between ARM and RISC-V in terms of design philosophies, ecosystem support, and application domains.
- Analyze the architectural foundations, instruction sets, and pipeline structures of ARM and RISC-V processors.
- Evaluate low-level hardware virtualisation mechanisms, GPU execution models, and RISC-V vector extensions by analysing architectural case studies and system diagrams.
- Implement ARM instruction set programs for exception handling and peripheral interfacing using coding exercises.
- Demonstrate the use of memory protection units and performance monitoring tools to analyze system performance.
- Apply RISC-V and ARM programming concepts to design and test simple embedded applications in an online simulation environment.
- Integrate ARM and RISC-V architectural concepts into embedded systems design workflows for practical applications.
- Evaluate trade-offs between ARM and RISC-V architectures when selecting processors for embedded or SoC design projects.
- Critically assess processor security and performance requirements and propose design solutions using TrustZone or RISC-V alternatives.
About
This course equips learners with the scripting and version control skills essential for streamlining modern VLSI design workflows. Beginning with Shell and TCL scripting, students learn to automate repetitive tasks and manage tool operations in electronic design automation (EDA) environments. These foundations are extended through Perl and Python, widely used in chip design for tasks such as data parsing, building automation frameworks, and handling large datasets. The course also introduces GitLab for source code management and collaborative development. Learners gain practical experience with version control systems, branching strategies, and workflow integration to manage design changes effectively within team-based projects. Through hands-on exercises and applied projects, students develop the ability to create robust automation scripts, optimize verification and implementation flows, and embed design processes into collaborative environments. The course is tailored for those seeking to accelerate chip development cycles and enhance productivity through intelligent automation. This module also examines modern design automation workflows, including AI-assisted EDA techniques for VLSI and embedded systems. Students evaluate how machine-learning-driven optimisation and NPU-aware design flows enhance synthesis, verification, and physical design efficiency.
Teachers
Intended learning outcomes
- Differentiate between manual design processes and automated workflows in terms of efficiency, accuracy, and scalability.
- Explain the role of scripting languages (Shell, TCL, Perl, Python) in automating VLSI design workflows.
- Describe the principles of version control systems, including branching strategies and collaborative workflows in GitLab.
- Apply AI-assisted design automation techniques to optimise synthesis, verification, or physical design workflows, evaluating their impact on design efficiency.
- Implement verification and design automation flows that improve productivity and reduce manual intervention.
- Develop automation scripts using Shell, TCL, Perl, and Python to perform EDA tool operations and data handling.
- Apply GitLab for version control by managing repositories, creating branches, and merging code for collaborative hardware design projects.
- Integrate scripting and version control tools to design end-to-end automation solutions for VLSI workflows.
- Collaborate effectively in a shared development environment by adhering to best practices for code management, documentation, and teamwork.
- Demonstrate industry readiness by presenting automated design frameworks that improve workflow efficiency and reliability in hardware development projects.
About
This course provides a thorough introduction to Design for Testability (DFT) techniques essential in modern VLSI design for ensuring manufacturability and achieving high fault coverage. Learners will study fundamental concepts such as Automatic Test Pattern Generation (ATPG), fault models (stuck-at, transition, bridging), scan chain insertion, test compression, boundary scan (IEEE 1149.1), and test coverage analysis. The course integrates both theoretical foundations and hands-on practice, allowing students to implement and verify test structures through lab-based exercises. By the end of the course, learners will be equipped with the knowledge and skills to design circuits for testability, evaluate coverage metrics, and apply industry-standard DFT methodologies to practical silicon design challenges.
Teachers
Intended learning outcomes
- Implement boundary scan and IJTAG networks following IEEE standards.
- Describe various fault models, including stuck-at, transition, and bridging, and their role in fault detection.
- Explain the principles of Design for Testability (DFT) and its importance in modern VLSI design.
- Identify and discuss DFT techniques such as ATPG, scan chains, test compression, and boundary scan.
- Implement scan chain insertion and test structures in sample circuit designs.
- Analyze test coverage reports to assess the effectiveness of different DFT strategies.
- Apply ATPG tools to generate test patterns for detecting faults in digital circuits.
- Evaluate trade-offs between fault coverage, design complexity, and test overhead in real-world DFT applications.
- Integrate multiple DFT techniques (e.g., scan chains, compression, boundary scan) into a coherent test strategy for VLSI circuits.
- Design and justify a complete DFT methodology for a given circuit, demonstrating its effectiveness through fault coverage analysis.
About
This course offers an in-depth exploration of SystemVerilog (SV) for both RTL design and functional verification, building a strong link between hardware description and validation. The course begins with RTL design using SystemVerilog, emphasizing synthesizable constructs, hierarchical design, and best practices for writing modular and reusable code. It then shifts focus to SystemVerilog as a Hardware Verification Language (HVL), introducing advanced verification techniques such as object-oriented programming, constrained randomization, and functional coverage. Learners will also gain proficiency in writing SystemVerilog Assertions (SVA) for property checking and applying formal verification to ensure design correctness early in the development cycle. Combining theoretical insights with hands-on practice, this course equips students with the ability to design reliable hardware and build efficient, assertion-based verification environments.
Teachers
Intended learning outcomes
- Explain the role of SystemVerilog in RTL design, including synthesizable constructs and hierarchical modeling.
- Discuss the principles of assertion-based verification and formal methods for early design validation.
- Describe advanced verification features of SystemVerilog, such as object-oriented programming, constrained randomization, and functional coverage.
- Develop SystemVerilog testbenches adhering to UVM guidelines.
- Develop and integrate SystemVerilog Assertions (SVA) to validate the functional correctness of hardware modules.
- Construct verification testbenches using SystemVerilog HVL features, including randomization and coverage-driven techniques.
- Apply SystemVerilog to implement clean, reusable RTL code following best design practices.
- Integrate formal verification techniques with simulation-based methods to ensure early detection of design errors.
- Evaluate design robustness by analyzing verification results using coverage metrics and assertion outcomes.
- Design and justify efficient verification environments that combine RTL coding, HVL methodologies, and SVA for comprehensive hardware validation.
- Demonstrate professional responsibility in managing collaborative verification workflows using version control systems (e.g., Git), including code reviews, issue tracking, and documentation of verification decisions.
About
This course offers immersive, project-based practice in VLSI and embedded systems, allowing students to translate theoretical knowledge into real-world design and verification tasks. Learners gain proficiency with industry-standard tools, scripting workflows, and complete design methodologies. By engaging with practical exercises across multiple domains, students build the applied expertise and confidence required for careers in the semiconductor and embedded systems industries.
Teachers
Intended learning outcomes
- Identify key features and use cases of industry-standard tools for simulation, synthesis, and verification.
- Describe scripting approaches and automation techniques relevant to semiconductor and embedded design flows.
- Explain the role of design, verification, and toolchains in VLSI and embedded workflows.
- Apply theoretical design principles to implement functional modules in simulation environments.
- Demonstrate proficiency in using scripting languages (e.g., Python, TCL, or shell) for design automation.
- Execute verification testbenches and analyze output to validate design correctness in lab projects.
- Design and deliver a project-based lab solution that demonstrates readiness for professional practice in semiconductor or embedded engineering.
- Integrate design, verification, and scripting practices into a complete, working embedded or VLSI prototype.
- Evaluate end-to-end design flows for efficiency, accuracy, and industry alignment using lab projects.
About
This course offers a comprehensive study of Physical Synthesis and Physical Design in the VLSI implementation flow, emphasizing the transformation of synthesized RTL into optimized and manufacturable layouts. Students will explore timing-driven placement, logic restructuring, and multi-objective optimization for area, power, and performance. The course further examines the complete Physical Design flow, covering floorplanning, placement, clock tree synthesis (CTS), routing, and signoff checks such as timing analysis. Through practical labs and industry-standard tool exercises, learners will develop the ability to perform both block-level and full-chip physical design, ensuring compliance with stringent fabrication and performance requirements.
Teachers
Intended learning outcomes
- Generate SDC constraints based on industry timing closure standards.
- Identify the trade-offs among area, power, performance, and manufacturability in physical design.
- Describe key concepts such as timing-driven placement, clock tree synthesis, and routing strategies.
- Explain the role of Physical Synthesis and Physical Design in the VLSI implementation flow.
- Apply floorplanning, placement, and CTS techniques using EDA tools for a given RTL design.
- Analyze signoff checks such as timing reports to verify the correctness and robustness of physical designs.
- Perform routing and optimization tasks to improve power, area, and timing characteristics of a layout.
- Design and justify a complete physical design flow for a given RTL, demonstrating compliance with fabrication and performance specifications.
- Exercise professional responsibility in evaluating and justifying physical design decisions with respect to timing closure, power consumption, silicon area, and manufacturability constraints.
- Integrate physical synthesis and design techniques to develop optimized full-chip or block-level layouts.
- Evaluate different physical design methodologies for efficiency, scalability, and design closure.
About
This course provides an applied, integrative experience across semiconductor and embedded system design, bridging theory with real-world practice. Students engage in structured projects that involve design tool flows, scripting, verification, and testing strategies. Working through sub-block or full-chip development cycles with guided mentorship, learners participate in milestone-based reviews and collaborative problem-solving. This experience cultivates a comprehensive understanding of how multiple disciplines converge in chip design and production, preparing students for professional engineering environments.
Teachers
Intended learning outcomes
- Explain the stages of a semiconductor/embedded system development cycle and their interdependencies.
- Summarize key verification and testing methodologies used in chip or embedded product design.
- Differentiate between sub-block and full-chip design approaches, including their complexity and scope.
- Develop functional design modules that align with project milestones and specifications.
- Demonstrate the ability to debug, validate, and optimize project outputs through iterative testing.
- Apply scripting, verification, and testing tools to implement specific stages of a pilot project.
- Manage an independently scoped technical project using iterative development practices, version control, and milestone-based delivery while responding to evolving technical constraints.
- Integrate design, verification, and testing techniques into a coherent, milestone-driven pilot project.
- Deliver a complete pilot project report and presentation that reflects industry-standard practices and demonstrates readiness for full-scale capstone projects or professional roles.
- Collaborate effectively in simulated professional workflows by contributing to reviews, feedback cycles, and problem-solving tasks.
About
This course provides an in-depth exploration of essential infrastructure components and software foundations in modern System-on-Chip (SoC) design. The course begins with a detailed study of memories and memory controllers, covering SRAM, DRAM, and Flash, along with interfacing methods and controller architectures designed to optimize latency, bandwidth, and power consumption. Learners will then examine Memory Management Units (MMUs) and virtual memory mechanisms such as address translation, paging, segmentation, and protection, which are integral to contemporary processor architectures. The course also focuses on interrupt controllers, exploring interrupt types, prioritization, masking, nested interrupts, and their integration with CPU cores to ensure responsive system performance. A dedicated section addresses SoC system controllers, including subsystems for clock and reset management, timers, power management units (PMUs), and pin multiplexing. Finally, the course introduces the SoC software stack, encompassing operating systems, firmware, device drivers, communication stacks, applications, and development toolchains. Through this, learners gain insights into the interplay between hardware and software, and how abstraction layers like firmware and drivers manage hardware resources effectively. The module extends system-on-chip design concepts to include hardware virtualisation support and AI-oriented accelerator integration. Students examine virtualised SoC interconnects, NPU dataflows, and RISC-V vector capabilities within modern heterogeneous SoC architectures.
Teachers
Intended learning outcomes
- Analyze the roles of interrupt controllers and system controllers (clock/reset, timers, PMUs, pin multiplexing) in SoC design.
- Explain the architecture and operation of different memory types (SRAM, DRAM, Flash) and memory controllers.
- Describe the principles of virtual memory management, including MMUs, address translation, paging, and protection.
- Design and evaluate system-on-chip architectures incorporating hardware virtualisation support, NPU dataflows, and vector-enabled processing elements.
- Develop simple firmware or device driver modules that interface with SoC hardware subsystems.
- Implement interrupt handling mechanisms, including prioritization and masking, in simulated SoC environments.
- Configure memory controllers and interfacing techniques to optimize SoC system performance.
- Demonstrate professional proficiency in designing SoC systems that balance hardware architecture with software abstraction layers to meet application-specific requirements.
- Evaluate SoC hardware-software interaction for efficiency, responsiveness, and power-performance trade-offs.
- Integrate hardware components (memories, controllers, interrupt systems) with software layers (drivers, OS, toolchains) in SoC design workflows.
About
This course serves as the culminating experience in the VLSI and Embedded Systems program, designed to replicate real-world industry challenges while showcasing learners’ ability to deliver production-ready solutions. Students address complex, open-ended engineering problems that require the integration of advanced technical expertise, innovative thinking, and effective project management. Through the complete development cycle—from ideation and architectural design to detailed implementation, verification, optimization, and deployment—learners gain hands-on experience in building robust systems. Projects may focus on domains such as VLSI RTL design and verification, embedded systems for IoT, low-power digital architectures, FPGA-based accelerators, or intelligent embedded applications. Throughout the course, students collaborate in teams, maintain structured documentation, adhere to professional and industry standards, and present their outcomes through functional prototypes and technical presentations. The Capstone Project directly supports the programme’s aims by requiring students to integrate advanced technical knowledge, applied research methods, professional judgement, ethical responsibility, and autonomous project management in the delivery of a complex VLSI or embedded systems solution.
Teachers
Intended learning outcomes
- Explain the principles of architectural planning, system-level design, and verification strategies in large-scale projects.
- Analyse legal, ethical, security, and professional responsibilities relevant to VLSI and embedded systems projects, including compliance with industry standards and regulatory constraints.
- Evaluate the relevance of design standards, compliance requirements, and professional practices in project development.
- Analyze complex engineering problems and identify feasible design approaches in VLSI/embedded systems.
- Apply advanced verification, testing, and optimization techniques to validate system performance.
- Produce clear and structured documentation, including design specifications, progress logs, and final reports that reflect industry norms.
- Design and implement functional prototypes by integrating multiple technical domains (e.g., VLSI design, IoT systems, FPGA acceleration).
- Integrate technical knowledge, creativity, and project management skills to deliver a complete, production-grade solution.
- Collaborate effectively in distributed teams by engaging in milestone reviews, peer feedback, and joint problem-solving.
- Present project outcomes through a functional prototype and a professional technical presentation, demonstrating readiness for industry roles.
- Demonstrate full professional autonomy by planning, executing, and delivering a complex VLSI or embedded systems project using collaborative tools, version control, and structured design reviews.
- Take responsibility for making and justifying engineering trade-offs involving performance, power, cost, timing, and system reliability in a real-world design context.
About
This course offers an advanced study of the RISC-V architecture, with a focus on system-level design and specialized extensions. Learners will develop a detailed understanding of privilege modes, memory protection, exception and interrupt handling, and system programming within RISC-V. Emphasis is placed on practical engagement with RISC-V toolchains, debugging methods, and application development for both embedded and general-purpose platforms. The course also introduces key ISA specifications such as PLIC, Debug, and Trace, alongside support for extensions including vector, atomic, floating-point, bit manipulation, and custom ISAs. By the end of the course, students will be equipped to leverage the flexibility of the open RISC-V ecosystem to design high-performance and domain-specific applications. This course also explores contemporary processor architectures with emphasis on hardware virtualisation support, throughput-oriented GPU designs, and heterogeneous computing paradigms. Learners critically evaluate hypervisor-aware architectures, GPU scheduling mechanisms, and advanced memory hierarchies using real-world architectural examples.
Teachers
Intended learning outcomes
- Identify and describe the role of ISA specifications such as PLIC, Debug, and Trace in system design.
- Explain RISC-V privilege modes, memory protection mechanisms, and system-level programming concepts.
- Discuss the purpose and functionality of advanced ISA extensions, including vector, atomic, floating-point, and bit manipulation instructions.
- Demonstrate the integration of RISC-V ISA extensions to optimize performance in application development.
- Apply RISC-V software toolchains to write, compile, and debug system-level programs.
- Implement exception and interrupt handling routines in RISC-V through coding and simulation exercises.
- Design and justify custom ISA extensions to address specific application or domain requirements within the RISC-V ecosystem.
- Critically assess advanced processor architectures supporting virtualisation, GPU-based parallelism, and heterogeneous computing, making informed architectural trade-offs based on performance and scalability constraints.
- Evaluate system design trade-offs when selecting RISC-V ISA extensions for high-performance and domain-specific applications.
- Integrate advanced RISC-V architectural features into embedded or general-purpose system workflows.
About
This course provides an in-depth exploration of advanced embedded system design, integrating both hardware and software perspectives. Learners will engage with embedded Linux programming, real-time operating system concepts, and security mechanisms for modern embedded platforms. The course introduces advanced processor architectures, hardware/software co-design methodologies, and parallel computing techniques to support the development of efficient, secure, and high-performance solutions. Practical application is emphasized through Linux-based environments and FPGA-based implementations, enabling learners to connect theoretical foundations with real-world embedded system applications.
Teachers
Intended learning outcomes
- Summarize advanced processor architectures, hardware/software co-design, and parallel computing strategies relevant to embedded systems.
- Explain the principles of embedded Linux programming and its role in system-level development.
- Apply MISRA-C and safety guidelines in embedded firmware.
- Describe real-time system design requirements and constraints for embedded platforms.
- Design an embedded system prototype (conceptual or simulation-based) that demonstrates the application of Linux programming, real-time features, and performance optimization.
- Integrate hardware and software components to design efficient embedded solutions for real-world applications
- Evaluate security considerations in embedded system design and propose methods to mitigate vulnerabilities.
- Analyze the impact of parallel computing approaches on the performance of embedded systems.
- Develop basic embedded applications using Linux-based programming environments.
- Implement real-time scheduling and synchronization mechanisms in simulated embedded contexts.
About
This course provides learners with the expertise to design and implement intelligent embedded solutions for edge and IoT environments. Starting with core principles of IoT and embedded machine learning, students advance to understanding industrial communication protocols, edge device orchestration, and secure data management. The curriculum emphasizes real-time AI inferencing, optimization of embedded models, and applications of generative AI in IoT and SoC workflows. With a strong hands-on approach, the course prepares engineers to create secure, scalable, and high-performance AI-driven embedded systems for edge computing.
Teachers
Intended learning outcomes
- Describe industrial communication protocols and their role in IoT and edge computing environments.
- Explain the foundational concepts of IoT architectures and embedded machine learning.
- Summarize methods of secure data handling, embedded model optimization, and real-time AI inferencing in edge devices.
- Apply embedded machine learning models to perform AI inferencing tasks on edge devices.
- Optimize pre-trained AI models for deployment in resource-constrained embedded platforms.
- Implement basic IoT workflows integrating industrial protocols in a simulated environment.
- Design a prototype (conceptual or simulation-based) of an intelligent embedded AI system for IoT/SoC workflows that demonstrates real-time inferencing and system orchestration.
- Evaluate security, scalability, and performance trade-offs in designing intelligent edge and IoT systems.
- Integrate embedded ML, industrial protocols, and secure data handling into an end-to-end IoT solution.
About
This course emphasizes the application of embedded systems across specialized domains such as robotics, automotive, healthcare, and RF technologies. Learners will engage with advanced topics including autonomous navigation for robotic platforms, RFIC and PCB-based system design, and the development of medical-grade embedded devices aligned with regulatory standards. The curriculum integrates advanced perception, signal integrity, cryptographic security, and system assurance to support the creation of robust, domain-specific embedded applications. Through real-world case studies and practical projects, students gain the expertise to address industry challenges and drive innovation in embedded product design and deployment. The course also explores embedded system design for AI-enabled applications, focusing on integration of NPUs and accelerator-centric processing pipelines. Learners evaluate accelerator dataflows, memory hierarchies, and HW–SW coordination in real-time embedded AI systems.
Teachers
Intended learning outcomes
- Describe principles of RFIC/PCB design, medical device compliance, and system assurance in embedded environments.
- Discuss advanced perception, signal integrity, and cryptographic security techniques for reliable embedded solutions.
- Explain domain-specific requirements of embedded systems in robotics, automotive, healthcare, and RF applications.
- Implement security mechanisms and system integrity checks in embedded prototypes using case-study scenarios.
- Demonstrate basic RF system design or PCB-level integration in a simulated toolchain.
- Apply autonomous navigation algorithms to simulated robotic or vehicular platforms.
- Evaluate embedded solutions for compliance, safety, and performance across healthcare, robotics, and automotive domains.
- Design a domain-driven embedded system prototype (simulation or project-based) addressing real-world constraints such as safety, compliance, and robustness.
- Demonstrate responsibility for deploying and validating embedded systems on FPGA or equivalent prototyping platforms, ensuring correct functionality under real-time constraints
- Evaluate and integrate NPU-based accelerator subsystems within embedded platforms, considering real-time constraints, memory hierarchies, and HW–SW coordination.
- Exercise professional judgement in balancing timing, power, and resource constraints during embedded system implementation and testing.
- Integrate perception, signal integrity, and cryptographic methods into a domain-specific embedded application design.
About
This course offers an in-depth introduction to the hardware foundations of modern electronics, focusing on Printed Circuit Board (PCB) design, semiconductor device physics, and wafer manufacturing processes. Learners will gain insights into PCB design workflows, including schematic capture, component placement, routing, and design rule checks, with particular attention to signal integrity and manufacturability. The course also examines the behavior and modeling of essential semiconductor devices such as diodes, BJTs, and MOSFETs, which underpin both analog and digital circuit design. Furthermore, it introduces the semiconductor fabrication process, covering wafer preparation, photolithography, doping, etching, and packaging techniques. By integrating these perspectives, students will develop a foundational understanding of how electronic systems are designed and realized—from raw silicon to complete board-level implementation.
Teachers
Intended learning outcomes
- Describe the fundamental behavior and modeling of semiconductor devices such as diodes, BJTs, and MOSFETs.
- Interpret JEDEC packaging standards in process-flow assessments.
- Summarize the steps involved in wafer fabrication, including photolithography, doping, etching, and packaging.
- Explain the principles of PCB design, including schematic capture, placement, routing, and design rule verification.
- Demonstrate the sequence of wafer fabrication steps through case-based or simulation-based exercises.
- Apply PCB design workflows using simulation or design software to ensure signal integrity and manufacturability.
- Analyze the electrical characteristics of semiconductor devices and evaluate their role in circuit performance.
- Design a simple PCB or circuit module, incorporating device characteristics and fabrication constraints, and justify the design decisions.
- Evaluate PCB design choices to balance manufacturability, performance, and signal integrity trade-offs.
- Integrate knowledge of semiconductor device physics and fabrication processes to explain how circuits transition from raw silicon to packaged devices.
About
This course provides a comprehensive exploration of the post-silicon phase of semiconductor development, emphasizing Packaging Design, Package Assembly, and IC Testing. Learners will examine the principles and design methodologies used in semiconductor packaging, with a focus on optimizing thermal, mechanical, and electrical performance. The course further introduces key assembly processes, including die attach, wire bonding, flip-chip technology, and encapsulation, highlighting issues of reliability and manufacturability. In addition, students will study integrated circuit (IC) testing approaches, such as wafer-level and package-level testing, test coverage evaluation, and defect detection methods. By integrating these elements, the course equips learners with the expertise to connect silicon fabrication with system-level deployment, ensuring robust and reliable chip production.
Teachers
Intended learning outcomes
- Explain the principles of semiconductor packaging design, considering thermal, mechanical, and electrical requirements.
- Summarize IC testing methodologies, including wafer-level and package-level testing, and their role in quality assurance.
- Describe the major IC assembly techniques, including die attach, wire bonding, flip-chip, and encapsulation.
- Apply design considerations to evaluate package types for different performance and reliability requirements.
- Demonstrate understanding of package assembly workflows through simulation, case studies, or virtual labs.
- Analyze IC test results and identify common manufacturing defects or performance limitations.
- Design a package-testing strategy for a given semiconductor device, justifying the approach in terms of coverage, defect detection, and system-level reliability.
- Integrate knowledge of packaging, assembly, and testing to propose solutions for real-world chip deployment challenges.
- Evaluate trade-offs in packaging design decisions with respect to manufacturability, reliability, and performance.
About
This course provides learners with a deep understanding of emerging innovations in System-on-Chip architectures, with a particular focus on multi-die and chiplet-based systems. The course begins with an overview of Systems of Chips, chiplets, and advanced integration techniques, emphasizing the industry transition from monolithic designs to modular and scalable architectures. A central theme is the Universal Chiplet Interconnect Express (UCIe), a new standard enabling seamless, high-bandwidth die-to-die communication across heterogeneous components. Learners will also engage with a case study on RISC-V SoC design, exploring open-source hardware concepts, subsystem integration, and real-world design flows. This applied component reinforces architectural principles while highlighting practical industry practices. By the end of the course, students will be equipped with advanced knowledge of SoC design concepts, interconnect protocols, and multi-die integration strategies, preparing them for roles in silicon design, system architecture, and semiconductor product development. This course also focuses on advanced SoC architectures incorporating hardware virtualisation, AI accelerators, and hardware–software co-design methodologies. Learners design and evaluate simplified accelerator blocks within SoC pipelines, analysing performance, memory access, and HW–SW interaction for AI workloads.
Teachers
Intended learning outcomes
- Explain the principles of multi-die and chiplet-based architectures, contrasting them with monolithic SoC designs.
- Describe the UCIe standard and its role in enabling die-to-die communication across heterogeneous components.
- Validate interconnect compliance with AMBA AXI specifications.
- Analyze open-source RISC-V SoC architectures and subsystems within the context of modern design flows.
- Develop design experiments or simulations to evaluate UCIe-based die-to-die interconnect performance.
- Apply SoC integration methodologies to model modular chiplet-based systems.
- Implement subsystem integration in a RISC-V SoC design flow using open-source design tools.
- Design and justify accelerator-integrated SoC pipelines, assessing hardware–software interactions and performance trade-offs in AI-oriented workloads.
- Lead and manage iterative and agile hardware development cycles for complex SoC designs, coordinating collaborative tasks, integrating IP blocks, and making informed trade-offs across performance, power, area, and cost constraints.
- Demonstrate the ability to apply advanced SoC design principles and open-source methodologies to real-world system architecture challenges.
- Demonstrate autonomy in selecting appropriate prototyping, verification, and integration strategies, including FPGA-based validation and collaborative version-controlled workflows.
- Integrate chiplet-based components and interconnect standards to design scalable multi-die SoC systems.
- Evaluate trade-offs in SoC architectures with respect to performance, scalability, cost, and manufacturability in advanced semiconductor products.
About
This course provides an in-depth study of front-end design challenges and solutions in advanced digital systems, with emphasis on Clock Domain Crossing (CDC), Reset Domain Crossing (RDC), low-power design methodologies, and RTL signoff techniques. Learners will explore methods to identify and resolve CDC and RDC issues for robust data transfer across asynchronous domains. The course also examines low-power design strategies, such as clock gating, power gating, multi-voltage operation, and UPF-based power intent specification. In addition, students will gain hands-on experience with RTL linting, logic synthesis, and formal equivalence checking, ensuring that RTL designs are functionally accurate, optimized, and ready for physical implementation. Through a mix of theoretical concepts and tool-driven labs, learners will build the ability to address design quality, power efficiency, and correctness in complex SoC and ASIC development.
Teachers
Intended learning outcomes
- Apply UPF/CPF specifications in low-power design flows
- Describe low-power design methodologies, including clock gating, power gating, and UPF-based specifications.
- Outline the principles of RTL signoff processes such as linting, logic synthesis, and equivalence checking.
- Explain the concepts of CDC and RDC, and their impact on digital system reliability
- Implement low-power design strategies in RTL using UPF specifications and power optimization methods.
- Apply CDC and RDC verification techniques using EDA tools to detect and resolve domain-crossing issues.
- Perform RTL linting, synthesis, and formal equivalence checks to validate design readiness for physical implementation.
- Design and justify a verified RTL module or subsystem that demonstrates reliable asynchronous communication, power optimization, and functional correctness.
- Evaluate design choices for robustness, low-power efficiency, and correctness in advanced SoC and ASIC development.
- Integrate CDC/RDC solutions, low-power design techniques, and RTL signoff practices into a cohesive front-end design flow.
About
This course offers an in-depth exploration of FPGA-based digital system design, starting with the fundamentals and progressing to advanced implementation techniques. Learners will study FPGA architectures, design flows, and hardware description languages (Verilog/VHDL) to model and realize digital circuits on reconfigurable hardware. The curriculum extends to advanced topics such as IP integration, high-speed interfaces, clocking strategies, and design optimization with respect to performance, power, and area. Students will also engage with specialized FPGA features, including embedded processors, DSP blocks, and high-level synthesis (HLS) for design acceleration. Through hands-on labs and project-based activities, participants will acquire practical expertise in developing, verifying, and deploying complex FPGA-based designs, preparing them for applications in prototyping, embedded systems, and hardware acceleration.
Teachers
Intended learning outcomes
- Explain the architecture, design flow, and hardware description approaches (Verilog/VHDL) used in FPGA-based systems.
- Identify design trade-offs in performance, area, and power for FPGA implementations.
- Describe advanced FPGA capabilities, including embedded processors, DSP blocks, and HLS methodologies.
- Apply IP integration, clocking strategies, and high-speed interface design in FPGA projects.
- Use FPGA design tools to perform synthesis, simulation, and optimization for area, performance, and power.
- Develop digital circuits in Verilog or VHDL and implement them on FPGA platforms.
- Evaluate FPGA design solutions for efficiency, scalability, and suitability in real-world applications such as prototyping or embedded systems.
- Integrate advanced FPGA features (DSP blocks, embedded processors, HLS) into functional system-level designs.
- Design and justify a complete FPGA-based project that demonstrates correct functionality, optimization, and deployment readiness.
About
This course provides a comprehensive study of Analog and Mixed-Signal (AMS) Integrated Circuit (IC) Design, combining theoretical foundations with advanced design and verification methodologies. Beginning with core circuit theory to establish analytical rigor, students will design essential analog building blocks such as current mirrors, differential amplifiers, and operational amplifiers. The course advances into specialized topics including biasing strategies, frequency compensation, noise analysis, and low-power/low-voltage design techniques. Learners will also develop expertise in AMS behavioral modeling and verification, applying high-level abstractions to model analog behavior and validate mixed-signal systems. Through a blend of theoretical analysis, simulations, and project-based labs, students will gain the ability to design, analyze, and verify complex AMS circuits, preparing them for applications in communication, sensing, and power management systems.
This module also addresses advanced digital design techniques for high-throughput computing, including GPU-inspired parallel architectures. Students analyse SIMT processing elements, warp scheduling concepts, and throughput-driven VLSI design strategies through design-oriented exercises.
Teachers
Intended learning outcomes
- Explain fundamental circuit theory concepts as they apply to analog and AMS IC design.
- Describe the operation and characteristics of analog building blocks such as current mirrors, differential amplifiers, and op-amps.
- Summarize advanced analog design considerations, including biasing, frequency compensation, noise analysis, and low-power/low-voltage techniques.
- Apply techniques for frequency compensation, biasing, and noise analysis in analog and mixed-signal circuits.
- Analyse and implement throughput-oriented digital design techniques inspired by GPU architectures, including SIMT execution and parallel scheduling concepts.
- Use AMS behavioral modeling to simulate and verify the performance of mixed-signal systems.
- Design analog circuits (e.g., current mirrors, differential amplifiers, op-amps) using simulation tools.
- Design and justify a complete AMS project that demonstrates robust design methodology, simulation-based verification, and system-level applicability.
- Integrate analog building blocks into mixed-signal architectures for applications in communication, sensing, and power management.
- Evaluate analog and AMS circuit designs for trade-offs involving power, performance, and noise.
About
This course introduces students to advanced verification and debugging techniques within the digital design flow, with a particular emphasis on Gate-Level Simulation (GLS) and the Universal Verification Methodology (UVM). Learners will explore the role of GLS in validating post-synthesis and post-place-and-route netlists, focusing on critical issues such as timing accuracy, glitches, and X-propagation. The course further provides a comprehensive overview of UVM, an industry-standard framework for developing reusable, modular, and scalable verification environments in SystemVerilog. Key topics include transaction-level modeling, sequences, drivers, monitors, and scoreboards, along with portable stimulus generation demonstrated through a case study. Through practical labs and simulation-based exercises, students will gain hands-on experience in debugging gate-level designs and constructing structured verification environments for complex SoC implementations.
Teachers
Intended learning outcomes
- Describe the components and principles of the Universal Verification Methodology (UVM).
- Summarize common verification challenges such as timing issues, glitches, and X-propagation in GLS.
- Explain the purpose and workflow of gate-level simulation in digital design verification.
- Apply transaction-level modeling and portable stimulus techniques in verification scenarios.
- Perform gate-level simulations to validate post-synthesis and post-layout netlists using EDA tools.
- Construct modular testbenches in SystemVerilog using UVM concepts such as drivers, monitors, and scoreboards
- Design and justify a complete verification project that demonstrates debugging proficiency and UVM-based environment development.
- Integrate UVM components into structured, reusable verification environments for SoC designs.
- Evaluate GLS results to identify and resolve issues related to timing, glitches, and X-propagation.
About
This course delves into power-aware verification methodologies that are crucial for developing modern, energy-efficient integrated circuits. With power efficiency now a key requirement in applications such as mobile devices and IoT systems, this course emphasizes the importance of verifying low-power intent across different stages of the design cycle. Learners will study the IEEE 1801 Unified Power Format (UPF), which defines power management intent separately from RTL design. Key topics include the fundamentals of UPF-based design and verification—covering power domain creation, isolation techniques, level shifting, retention mechanisms, and power state tables. The course also highlights how UPF integrates into simulation and verification workflows to accurately model power intent and detect functional issues such as missing retention or faulty isolation. Through guided labs and hands-on exercises, participants will learn to set up UPF verification environments, conduct power-aware checks, and validate designs under various power conditions. By the end of the course, students will be equipped to analyze, detect, and resolve low-power design issues, ensuring functional correctness in complex, low-energy VLSI systems.
Teachers
Intended learning outcomes
- Describe the role of the IEEE 1801 Unified Power Format (UPF) in specifying power intent independent of RTL.
- Differentiate between power management techniques such as isolation, retention, and level shifting in UPF-based verification
- Explain the principles of power-aware verification and its significance in modern low-power VLSI design.
- Apply UPF concepts to define power domains, isolation strategies, and power state tables for given design scenarios.
- Debug low-power design issues such as missing retention or incorrect isolation through simulation-based case studies.
- Implement power-aware verification checks within simulation workflows to validate power intent.
- Integrate UPF methodologies into SoC verification flows to ensure scalability and accuracy in power-aware simulations.
- Propose optimized verification strategies to address energy-efficiency challenges in advanced VLSI designs.
- Evaluate design correctness under multiple power scenarios using UPF-based verification environments
About
This course offers an in-depth study of digital design implementation and testing methodologies, blending theoretical concepts with practical training on industry-standard Synopsys tools. It begins with RTL linting to detect coding errors, design rule violations, and structural issues early in the design cycle. Students will then perform RTL synthesis, applying design constraints and incremental optimizations following DFT (Design for Test) insertion. The course also emphasizes formal equivalence checking to ensure functional correctness between RTL and synthesized netlists. In the testing domain, learners will study and apply advanced techniques such as LBIST (Logic Built-In Self-Test), MBIST (Memory Built-In Self-Test), and test compression methods to enhance in-system testing efficiency and reduce test overhead. Through guided labs, students will gain hands-on experience in preparing robust, testable, and silicon-ready designs.
Teachers
Intended learning outcomes
- Describe the process of RTL synthesis, including constraint handling and incremental optimization post-DFT insertion.
- Explain the principles of RTL linting and its role in identifying coding and structural issues in digital designs.
- Discuss advanced test methodologies such as LBIST, MBIST, and test compression and their importance in VLSI design.
- Apply RTL linting techniques to detect and resolve common coding and design rule violations using Synopsys tools.
- Perform RTL synthesis with design constraints and incremental optimizations to generate optimized, testable netlists.
- Implement formal equivalence checking to validate functional consistency between RTL and synthesized netlists.
- Evaluate and deliver fully testable designs, demonstrating readiness for silicon implementation through lab-based verification projects.
- Develop efficient test compression strategies that minimize pattern volume and reduce test execution time.
- Integrate LBIST and MBIST strategies to enhance the reliability of digital systems under real-world conditions
About
This course delves into advanced Design-for-Testability (DFT) strategies tailored for low-power and complex SoC architectures. It emphasizes power-aware testing techniques to address challenges such as multi-power domains, power gating, and clock gating, ensuring efficient testability while maintaining high fault coverage. The course also introduces the IEEE 1687 (IJTAG) standard, which provides a scalable approach to accessing embedded instruments within SoC IP blocks. Students will gain hands-on experience in integrating IJTAG into SoC test infrastructures, enabling modular and reusable test solutions. Through a blend of theory and practical labs, learners will develop the ability to implement robust, power-aware, and standards-compliant DFT methodologies for modern SoC designs.
Teachers
Intended learning outcomes
- Analyze the impact of power-aware test techniques on fault coverage and SoC performance.
- Describe the role and structure of IEEE 1687 (IJTAG) in enabling efficient test access for embedded instruments.
- Explain the principles of low-power DFT strategies, including power gating, multi-domain testing, and clock gating.
- Demonstrate the use of IJTAG for configuring and accessing embedded instruments in SoC IP blocks.
- Apply low-power DFT methodologies to verify designs with multiple power domains in a simulated environment.
- Implement test flows that integrate power-aware strategies while optimizing test coverage and runtime.
- Evaluate trade-offs between power efficiency, test coverage, and test time when applying advanced DFT techniques.
- Critically assess and justify DFT methodologies for complex low-power SoCs in terms of industry compliance and practical feasibility.
- Design a scalable, reusable test infrastructure for SoC designs using IJTAG principles.
About
This course provides an in-depth understanding of advanced Static Timing Analysis (STA) and Physical Verification processes essential for ensuring both the functional accuracy and physical integrity of digital IC designs. Learners will study advanced STA concepts, including multi-mode multi-corner (MMMC) analysis, timing exceptions, clock domain crossing (CDC) verification, and techniques for managing on-chip variation (OCV). The course further explores critical Physical Verification steps such as Design Rule Checking (DRC), Layout Versus Schematic (LVS), Antenna Rule checks, and Electrostatic Discharge (ESD) compliance, leading to complete sign-off readiness. Emphasis is placed on applying industry-standard methodologies and EDA tool flows for achieving timing closure and manufacturability. Hands-on labs and case studies provide practical exposure to timing closure strategies, physical verification, and sign-off preparation, enabling students to confidently prepare designs for successful tape-out.
Teachers
Intended learning outcomes
- Differentiate between functional verification and sign-off processes, emphasizing their roles in achieving design closure and manufacturability.
- Explain advanced STA principles such as MMMC analysis, timing exceptions, and OCV handling in the context of VLSI design.
- Describe the purpose and methodology of physical verification steps including DRC, LVS, Antenna checks, and ESD compliance.
- Apply MMMC analysis techniques to evaluate timing performance across different operating conditions using industry-standard tools.
- Demonstrate the use of EDA workflows to implement timing closure strategies and prepare a design for sign-off readiness.
- Perform physical verification tasks such as DRC and LVS checks to identify and resolve design rule violations in IC layouts.
- Integrate STA and physical verification methodologies into a comprehensive flow that ensures both functional correctness and manufacturability.
- Develop sign-off-ready design reports that effectively communicate timing closure results, verification outcomes, and tape-out readiness for professional review.
- Evaluate design trade-offs and propose solutions to timing and physical verification challenges in complex digital IC designs.
About
This course delves into advanced practices in digital IC implementation, with emphasis on power-aware physical design, AI-driven optimization, logic equivalence checking, and signal integrity analysis. Students will study methods to reduce both dynamic and static power during placement, routing, and clock tree synthesis, while integrating power intent specifications and multi-voltage domain design. The curriculum also highlights emerging AI/ML-based approaches for placement, congestion prediction, and timing closure, improving both productivity and design quality. A dedicated module on logic equivalence checking ensures functional alignment across design stages, from RTL through gate-level representations. Furthermore, learners will investigate signal integrity challenges such as crosstalk, noise, and delay variations, and apply corrective measures during physical design. Through hands-on labs and real-world case studies, students will acquire practical expertise in building high-performance, low-power chips using modern, intelligent design methodologies.
Teachers
Intended learning outcomes
- Explain techniques for reducing dynamic and static power in placement, routing, and clock tree synthesis.
- Describe AI/ML-based methodologies applied to placement optimization, congestion prediction, and timing closure.
- Summarize the principles of logic equivalence checking and signal integrity analysis in advanced physical design.
- Demonstrate the use of AI/ML-assisted tools to optimize design quality and productivity during IC implementation.
- Apply power intent specifications and multi-voltage domain strategies in a physical design flow.
- Perform signal integrity analysis (crosstalk, noise, delay variations) and propose suitable mitigation strategies.
- Evaluate the effectiveness of AI-driven optimization techniques in addressing timing closure challenges for complex SoCs.
- Integrate power-aware design methodologies with logic equivalence checking to ensure consistency across design transformations.
- Design a power-efficient, high-performance chip implementation flow that balances power, performance, and signal integrity trade-offs.
About
This course introduces learners to the fundamental and performance-driven principles of modern computer systems. The course begins with an exploration of processor instruction set architectures (ISAs), covering both RISC and CISC paradigms, as well as system-level models such as Von Neumann and Harvard architectures. Learners study essential components, including address, data, and control buses, interrupt controllers, and Direct Memory Access (DMA), alongside the fundamentals of memory organization. The course then covers virtual memory concepts such as address translation, page tables, and Translation Lookaside Buffers (TLBs). Building on this foundation, learners engage with high-performance design techniques, including instruction pipelining, address pipelining, and parallel processing. A dedicated unit on cache architecture provides an in-depth understanding of the memory hierarchy, cache mapping methods, replacement and write policies, and coherence protocols, including an introduction to the Cache Coherent Interconnect for Accelerators (CHI). By connecting theory with real-world processor design practices, the course equips students with insights into how modern systems achieve efficiency, scalability, and performance.
Teachers
Intended learning outcomes
- Describe the role of buses, interrupt controllers, DMA, and memory organization in computer architecture.
- Apply IEEE 754 FP behaviour in datapath design exercises.
- Explain the principles of processor instruction set architectures (RISC and CISC) and system-level models.
- Analyze cache design principles, including mapping, replacement policies, and coherence protocols such as CHI.
- Implement basic models of instruction pipelining and parallel execution in a simulated processor environment.
- Simulate and test cache behavior under different mapping and replacement policies to assess performance trade-offs.
- Illustrate the process of virtual memory translation using page tables and TLBs through examples or simulations.
- Evaluate architectural trade-offs between performance, efficiency, and scalability in processor design.
- Integrate concepts of ISAs, pipelining, memory systems, and cache design into a simplified processor model.
- Demonstrate professional-level understanding by applying architectural concepts to real-world case studies of modern high-performance processors.
About
This course offers an in-depth study of two major processor architectures: ARM and RISC-V. It begins with the core principles of reduced instruction set computing (RISC), providing students with a solid understanding of their architectural foundations, instruction sets, and pipeline structures. Learners will then explore ARM-specific features, including software interfaces, exception handling, and peripheral programming, reinforced through practical coding exercises. The course advances into topics such as ARM TrustZone, memory protection units, and performance monitoring, highlighting security and optimization techniques. Alongside, comparative discussions of ARM and RISC-V design philosophies and ecosystem support prepare learners for embedded system development and System-on-Chip (SoC)-level integration using both architectures. This module also introduces advanced architectural features including low-level hardware virtualisation mechanisms, GPU execution models, and vector processing extensions. Students analyse MMU/IOMMU support, SIMT-based GPU architectures, and RISC-V Vector Extensions through comparative architectural case studies.
Teachers
Intended learning outcomes
- Describe advanced ARM features such as TrustZone, memory protection units, and performance monitoring in the context of security and efficiency.
- Differentiate between ARM and RISC-V in terms of design philosophies, ecosystem support, and application domains.
- Analyze the architectural foundations, instruction sets, and pipeline structures of ARM and RISC-V processors.
- Evaluate low-level hardware virtualisation mechanisms, GPU execution models, and RISC-V vector extensions by analysing architectural case studies and system diagrams.
- Implement ARM instruction set programs for exception handling and peripheral interfacing using coding exercises.
- Demonstrate the use of memory protection units and performance monitoring tools to analyze system performance.
- Apply RISC-V and ARM programming concepts to design and test simple embedded applications in an online simulation environment.
- Integrate ARM and RISC-V architectural concepts into embedded systems design workflows for practical applications.
- Evaluate trade-offs between ARM and RISC-V architectures when selecting processors for embedded or SoC design projects.
- Critically assess processor security and performance requirements and propose design solutions using TrustZone or RISC-V alternatives.
About
This course equips learners with the scripting and version control skills essential for streamlining modern VLSI design workflows. Beginning with Shell and TCL scripting, students learn to automate repetitive tasks and manage tool operations in electronic design automation (EDA) environments. These foundations are extended through Perl and Python, widely used in chip design for tasks such as data parsing, building automation frameworks, and handling large datasets. The course also introduces GitLab for source code management and collaborative development. Learners gain practical experience with version control systems, branching strategies, and workflow integration to manage design changes effectively within team-based projects. Through hands-on exercises and applied projects, students develop the ability to create robust automation scripts, optimize verification and implementation flows, and embed design processes into collaborative environments. The course is tailored for those seeking to accelerate chip development cycles and enhance productivity through intelligent automation. This module also examines modern design automation workflows, including AI-assisted EDA techniques for VLSI and embedded systems. Students evaluate how machine-learning-driven optimisation and NPU-aware design flows enhance synthesis, verification, and physical design efficiency.
Teachers
Intended learning outcomes
- Differentiate between manual design processes and automated workflows in terms of efficiency, accuracy, and scalability.
- Explain the role of scripting languages (Shell, TCL, Perl, Python) in automating VLSI design workflows.
- Describe the principles of version control systems, including branching strategies and collaborative workflows in GitLab.
- Apply AI-assisted design automation techniques to optimise synthesis, verification, or physical design workflows, evaluating their impact on design efficiency.
- Implement verification and design automation flows that improve productivity and reduce manual intervention.
- Develop automation scripts using Shell, TCL, Perl, and Python to perform EDA tool operations and data handling.
- Apply GitLab for version control by managing repositories, creating branches, and merging code for collaborative hardware design projects.
- Integrate scripting and version control tools to design end-to-end automation solutions for VLSI workflows.
- Collaborate effectively in a shared development environment by adhering to best practices for code management, documentation, and teamwork.
- Demonstrate industry readiness by presenting automated design frameworks that improve workflow efficiency and reliability in hardware development projects.
About
This course provides a thorough introduction to Design for Testability (DFT) techniques essential in modern VLSI design for ensuring manufacturability and achieving high fault coverage. Learners will study fundamental concepts such as Automatic Test Pattern Generation (ATPG), fault models (stuck-at, transition, bridging), scan chain insertion, test compression, boundary scan (IEEE 1149.1), and test coverage analysis. The course integrates both theoretical foundations and hands-on practice, allowing students to implement and verify test structures through lab-based exercises. By the end of the course, learners will be equipped with the knowledge and skills to design circuits for testability, evaluate coverage metrics, and apply industry-standard DFT methodologies to practical silicon design challenges.
Teachers
Intended learning outcomes
- Implement boundary scan and IJTAG networks following IEEE standards.
- Describe various fault models, including stuck-at, transition, and bridging, and their role in fault detection.
- Explain the principles of Design for Testability (DFT) and its importance in modern VLSI design.
- Identify and discuss DFT techniques such as ATPG, scan chains, test compression, and boundary scan.
- Implement scan chain insertion and test structures in sample circuit designs.
- Analyze test coverage reports to assess the effectiveness of different DFT strategies.
- Apply ATPG tools to generate test patterns for detecting faults in digital circuits.
- Evaluate trade-offs between fault coverage, design complexity, and test overhead in real-world DFT applications.
- Integrate multiple DFT techniques (e.g., scan chains, compression, boundary scan) into a coherent test strategy for VLSI circuits.
- Design and justify a complete DFT methodology for a given circuit, demonstrating its effectiveness through fault coverage analysis.
About
This course offers an in-depth exploration of SystemVerilog (SV) for both RTL design and functional verification, building a strong link between hardware description and validation. The course begins with RTL design using SystemVerilog, emphasizing synthesizable constructs, hierarchical design, and best practices for writing modular and reusable code. It then shifts focus to SystemVerilog as a Hardware Verification Language (HVL), introducing advanced verification techniques such as object-oriented programming, constrained randomization, and functional coverage. Learners will also gain proficiency in writing SystemVerilog Assertions (SVA) for property checking and applying formal verification to ensure design correctness early in the development cycle. Combining theoretical insights with hands-on practice, this course equips students with the ability to design reliable hardware and build efficient, assertion-based verification environments.
Teachers
Intended learning outcomes
- Explain the role of SystemVerilog in RTL design, including synthesizable constructs and hierarchical modeling.
- Discuss the principles of assertion-based verification and formal methods for early design validation.
- Describe advanced verification features of SystemVerilog, such as object-oriented programming, constrained randomization, and functional coverage.
- Develop SystemVerilog testbenches adhering to UVM guidelines.
- Develop and integrate SystemVerilog Assertions (SVA) to validate the functional correctness of hardware modules.
- Construct verification testbenches using SystemVerilog HVL features, including randomization and coverage-driven techniques.
- Apply SystemVerilog to implement clean, reusable RTL code following best design practices.
- Integrate formal verification techniques with simulation-based methods to ensure early detection of design errors.
- Evaluate design robustness by analyzing verification results using coverage metrics and assertion outcomes.
- Design and justify efficient verification environments that combine RTL coding, HVL methodologies, and SVA for comprehensive hardware validation.
- Demonstrate professional responsibility in managing collaborative verification workflows using version control systems (e.g., Git), including code reviews, issue tracking, and documentation of verification decisions.
About
This course lays the foundation for developing and debugging modern embedded systems. The course begins with hardware system interfacing fundamentals and introduces learners to microprocessors and microcontrollers, with platforms such as STMicroelectronics serving as examples. Emphasis is placed on embedded C programming for system-level applications. Learners also gain exposure to the ARM Instruction Set Architecture (ISA) and supporting toolchains, while exploring key quality attributes of embedded systems. Additionally, the course introduces debug interfaces and debuggers such as SWD and JTAG, providing practical insight into low-level programming, system control, and debugging practices essential for embedded system development.
Teachers
Intended learning outcomes
- Describe the ARM Instruction Set Architecture (ISA) and associated toolchains used in embedded system development.
- Explain the fundamentals of embedded system architecture, including microprocessors, microcontrollers, and hardware interfacing.
- Analyze the quality attributes of embedded systems, such as reliability, efficiency, and scalability.
- Interpret instruction-set specifications (RISC-V/ARM) in program design.
- Use debugging tools (e.g., SWD, JTAG) to identify and resolve errors in embedded systems.
- Implement basic system interfacing techniques to integrate hardware components with microcontrollers.
- Write embedded C programs for microcontroller-based applications.
- Demonstrate professional proficiency in low-level programming and system control for embedded applications aligned with real-world design standards.
- Integrate microcontroller platforms, embedded C, and debugging techniques to develop functional embedded applications.
- Evaluate embedded systems for performance and quality, applying industry-relevant metrics and debugging practices.
About
This course builds on foundational concepts to provide learners with a comprehensive understanding of embedded peripheral interfaces from a programmer’s perspective. The course explores the internal functionality and software-level integration of analog and digital peripherals, such as ADCs, DACs, sensors, buttons, LEDs, LCDs, and other input/output devices, using microcontroller platforms. Learners will gain practical experience in controlling and interfacing peripherals through embedded programming.
In addition, the course introduces the fundamentals of embedded networking, covering widely used communication stacks and protocols including TCP/IP and UDP. Emphasis is placed on the layered architecture of networking stacks, packet structures, socket programming, and applications in IoT and embedded systems. Through applied programming exercises and lab-based activities, learners will acquire hands-on skills in peripheral integration and implementing network communication protocols for real-world embedded applications.
Teachers
Intended learning outcomes
- Explain the principles of analog and digital peripheral interfacing, including ADCs, DACs, input devices, and display systems.
- Describe the layered architecture of networking stacks, packet structures, and common embedded communication protocols such as TCP/IP and UDP.
- Explain functional safety principles (ISO 26262) in embedded applications.
- Analyze the role of peripheral devices and communication stacks in the functionality and performance of embedded systems.
- Write embedded programs to control and interface analog and digital peripherals with microcontrollers.
- Implement socket programming and communication protocols to enable data exchange in embedded systems.
- Simulate and test embedded applications that integrate peripherals and networking protocols for correctness and efficiency.
- Integrate multiple peripheral devices with microcontrollers to design functional embedded applications.
- Demonstrate professional proficiency in designing and debugging embedded systems that combine peripheral interfacing and network communication.
- Evaluate embedded networking solutions for IoT and real-time applications, considering performance, scalability, and reliability.
About
This course offers immersive, project-based practice in VLSI and embedded systems, allowing students to translate theoretical knowledge into real-world design and verification tasks. Learners gain proficiency with industry-standard tools, scripting workflows, and complete design methodologies. By engaging with practical exercises across multiple domains, students build the applied expertise and confidence required for careers in the semiconductor and embedded systems industries.
Teachers
Intended learning outcomes
- Identify key features and use cases of industry-standard tools for simulation, synthesis, and verification.
- Describe scripting approaches and automation techniques relevant to semiconductor and embedded design flows.
- Explain the role of design, verification, and toolchains in VLSI and embedded workflows.
- Apply theoretical design principles to implement functional modules in simulation environments.
- Demonstrate proficiency in using scripting languages (e.g., Python, TCL, or shell) for design automation.
- Execute verification testbenches and analyze output to validate design correctness in lab projects.
- Design and deliver a project-based lab solution that demonstrates readiness for professional practice in semiconductor or embedded engineering.
- Integrate design, verification, and scripting practices into a complete, working embedded or VLSI prototype.
- Evaluate end-to-end design flows for efficiency, accuracy, and industry alignment using lab projects.
About
This course offers a comprehensive study of Physical Synthesis and Physical Design in the VLSI implementation flow, emphasizing the transformation of synthesized RTL into optimized and manufacturable layouts. Students will explore timing-driven placement, logic restructuring, and multi-objective optimization for area, power, and performance. The course further examines the complete Physical Design flow, covering floorplanning, placement, clock tree synthesis (CTS), routing, and signoff checks such as timing analysis. Through practical labs and industry-standard tool exercises, learners will develop the ability to perform both block-level and full-chip physical design, ensuring compliance with stringent fabrication and performance requirements.
Teachers
Intended learning outcomes
- Generate SDC constraints based on industry timing closure standards.
- Identify the trade-offs among area, power, performance, and manufacturability in physical design.
- Describe key concepts such as timing-driven placement, clock tree synthesis, and routing strategies.
- Explain the role of Physical Synthesis and Physical Design in the VLSI implementation flow.
- Apply floorplanning, placement, and CTS techniques using EDA tools for a given RTL design.
- Analyze signoff checks such as timing reports to verify the correctness and robustness of physical designs.
- Perform routing and optimization tasks to improve power, area, and timing characteristics of a layout.
- Design and justify a complete physical design flow for a given RTL, demonstrating compliance with fabrication and performance specifications.
- Exercise professional responsibility in evaluating and justifying physical design decisions with respect to timing closure, power consumption, silicon area, and manufacturability constraints.
- Integrate physical synthesis and design techniques to develop optimized full-chip or block-level layouts.
- Evaluate different physical design methodologies for efficiency, scalability, and design closure.
About
This course provides an applied, integrative experience across semiconductor and embedded system design, bridging theory with real-world practice. Students engage in structured projects that involve design tool flows, scripting, verification, and testing strategies. Working through sub-block or full-chip development cycles with guided mentorship, learners participate in milestone-based reviews and collaborative problem-solving. This experience cultivates a comprehensive understanding of how multiple disciplines converge in chip design and production, preparing students for professional engineering environments.
Teachers
Intended learning outcomes
- Explain the stages of a semiconductor/embedded system development cycle and their interdependencies.
- Summarize key verification and testing methodologies used in chip or embedded product design.
- Differentiate between sub-block and full-chip design approaches, including their complexity and scope.
- Develop functional design modules that align with project milestones and specifications.
- Demonstrate the ability to debug, validate, and optimize project outputs through iterative testing.
- Apply scripting, verification, and testing tools to implement specific stages of a pilot project.
- Manage an independently scoped technical project using iterative development practices, version control, and milestone-based delivery while responding to evolving technical constraints.
- Integrate design, verification, and testing techniques into a coherent, milestone-driven pilot project.
- Deliver a complete pilot project report and presentation that reflects industry-standard practices and demonstrates readiness for full-scale capstone projects or professional roles.
- Collaborate effectively in simulated professional workflows by contributing to reviews, feedback cycles, and problem-solving tasks.
About
This course introduces learners to the architecture, design methodologies, and communication protocols central to modern System-on-Chip (SoC) development. The course begins with a detailed study of SoC architecture, emphasizing the integration of processing cores, memory subsystems, and hardware accelerators. Learners will gain an understanding of the complete SoC design flow, including specification, IP integration, simulation, synthesis, verification, and physical design. The course highlights interconnect protocols such as AXI, AHB, and APB, exploring how bridges and bus fabrics enable seamless communication between IP blocks. Additionally, students will examine processor–peripheral communication through protocols like I²C, SPI, UART, and GPIO, while also being introduced to wireless communication standards such as Wi-Fi and Bluetooth. Special focus is placed on their architectures, stack layers, and the integration challenges encountered in SoC design.
Teachers
Intended learning outcomes
- Describe the stages of the SoC design flow, from specification through physical design.
- Use AMBA/TileLink protocol specifications to construct SoC block diagrams.
- Explain the fundamental components of SoC architecture, including processing cores, memory systems, and hardware accelerators.
- Analyze the role of interconnect and communication protocols (AXI, AHB, APB, I²C, SPI, UART, GPIO, Wi-Fi, Bluetooth) in enabling efficient SoC integration.
- Develop simulations to evaluate IP integration and protocol-level communication within SoC subsystems.
- Use design and verification tools to test SoC components for functionality and protocol compliance.
- Apply SoC interconnect protocols to design simple processor–peripheral communication models.
- Evaluate processor–peripheral and wireless communication implementations for efficiency, scalability, and integration challenges.
- Integrate IP blocks, memory, and peripheral interfaces into a simplified SoC design using industry-relevant methodologies.
- Demonstrate the ability to design and refine SoC architectures that align with real-world performance, interoperability, and communication standards.
About
This course provides an in-depth exploration of essential infrastructure components and software foundations in modern System-on-Chip (SoC) design. The course begins with a detailed study of memories and memory controllers, covering SRAM, DRAM, and Flash, along with interfacing methods and controller architectures designed to optimize latency, bandwidth, and power consumption. Learners will then examine Memory Management Units (MMUs) and virtual memory mechanisms such as address translation, paging, segmentation, and protection, which are integral to contemporary processor architectures. The course also focuses on interrupt controllers, exploring interrupt types, prioritization, masking, nested interrupts, and their integration with CPU cores to ensure responsive system performance. A dedicated section addresses SoC system controllers, including subsystems for clock and reset management, timers, power management units (PMUs), and pin multiplexing. Finally, the course introduces the SoC software stack, encompassing operating systems, firmware, device drivers, communication stacks, applications, and development toolchains. Through this, learners gain insights into the interplay between hardware and software, and how abstraction layers like firmware and drivers manage hardware resources effectively. The module extends system-on-chip design concepts to include hardware virtualisation support and AI-oriented accelerator integration. Students examine virtualised SoC interconnects, NPU dataflows, and RISC-V vector capabilities within modern heterogeneous SoC architectures.
Teachers
Intended learning outcomes
- Analyze the roles of interrupt controllers and system controllers (clock/reset, timers, PMUs, pin multiplexing) in SoC design.
- Explain the architecture and operation of different memory types (SRAM, DRAM, Flash) and memory controllers.
- Describe the principles of virtual memory management, including MMUs, address translation, paging, and protection.
- Design and evaluate system-on-chip architectures incorporating hardware virtualisation support, NPU dataflows, and vector-enabled processing elements.
- Develop simple firmware or device driver modules that interface with SoC hardware subsystems.
- Implement interrupt handling mechanisms, including prioritization and masking, in simulated SoC environments.
- Configure memory controllers and interfacing techniques to optimize SoC system performance.
- Demonstrate professional proficiency in designing SoC systems that balance hardware architecture with software abstraction layers to meet application-specific requirements.
- Evaluate SoC hardware-software interaction for efficiency, responsiveness, and power-performance trade-offs.
- Integrate hardware components (memories, controllers, interrupt systems) with software layers (drivers, OS, toolchains) in SoC design workflows.
About
This course** provides learners with the foundational knowledge and applied skills essential for careers in the semiconductor and embedded systems industry. The course integrates theoretical concepts with practical implementation, covering both front-end and back-end VLSI design methodologies. Learners are introduced to VLSI design principles, ASIC and FPGA workflows, and industry-standard verification processes. Building on digital logic fundamentals, the course incorporates the RISC-V Instruction Set Architecture, guiding students toward the Register Transfer Level (RTL) design and implementation of a pipelined RISC-V processor. In addition, learners explore CMOS basics, full-custom ASIC design strategies, and critical timing concepts. By connecting digital electronics theory with practical applications, the course enables students to design systems that are functionally correct, synthesizable, and optimized for performance and resource efficiency.
Teachers
Intended learning outcomes
- Apply CMOS and PDK rule-based constraints in basic layout exercises.
- Describe the architecture and instruction set principles of RISC-V and its role in processor design.
- Explain the fundamental concepts of VLSI design, including ASIC and FPGA design flows.
- Analyze CMOS fundamentals and timing concepts relevant to full-custom ASIC design.
- Develop RTL-level models of a pipelined RISC-V processor using a hardware description language.
- Simulate and test VLSI designs to evaluate functional correctness, synthesizability, and performance trade-offs.
- Apply digital logic principles to design and verify combinational and sequential circuits.
- Integrate theoretical VLSI concepts with practical workflows to design optimized digital systems for performance and area.
- Collaborate in virtual design environments to solve VLSI implementation challenges using industry-standard tools.
- Demonstrate the ability to critically assess and refine VLSI designs in alignment with professional standards of the semiconductor industry.
About
This course provides a structured introduction to the Verilog Hardware Description Language (HDL), equipping learners with the ability to model, simulate, and design digital systems at the RTL level. The course begins with the fundamentals of Verilog, including modules, data types, procedural and continuous assignments, as well as behavioral and structural modeling. Learners will gain practical experience in hardware design environments through the use of Linux commands and the VI editor. Building on this foundation, the course advances to complex Verilog concepts such as tasks, functions, synthesizable constructs, and testbench development, with a strong emphasis on writing modular, reusable, and efficient code. Finally, learners are introduced to code coverage techniques, enabling them to evaluate verification quality and completeness effectively.
Teachers
Intended learning outcomes
- Design RTL blocks following IEEE 1800-compliant coding guidelines.
- Explain the core constructs of Verilog, including modules, assignments, and modeling techniques.
- Differentiate between behavioral, structural, and RTL-level descriptions in Verilog.
- Summarize advanced Verilog concepts such as synthesizable constructs, tasks, functions, and code coverage methods.
- Develop and execute testbenches to verify digital system functionality and assess correctness.
- Use Linux commands and the VI editor effectively to manage Verilog-based design projects in a typical hardware design environment.
- Write Verilog code to model and simulate combinational and sequential circuits at the RTL level.
- Demonstrate professional coding practices by adhering to industry standards for clarity, modularity, and reusability in hardware design.
- Integrate advanced Verilog features to design scalable, reusable, and synthesizable RTL code.
- Evaluate verification completeness using code coverage metrics and refine test strategies accordingly.
Master of Science in VLSI Design and Embedded Systems
Downloads
Apply Now
Ready to start your journey? Apply for Master of Science in VLSI Design and Embedded Systems today.