Computer engineering is a challenging but rewarding field that combines the principles of electrical engineering and computer science.
It’s a vast and ever-evolving discipline, so finding the right course to start your journey can feel overwhelming.
After thorough research and evaluation, we’ve selected the FPGA Design for Embedded Systems Specialization as the best overall computer engineering course on Coursera.
This specialization from the University of Colorado Boulder offers a hands-on approach to designing and implementing complex electronic systems using FPGAs.
It starts with the basics of FPGA technology and progresses to advanced topics like hardware description languages, softcore processors, and FPGA projects.
But don’t worry if this isn’t quite the right fit for you.
We’ve got more options to explore.
Keep reading for recommendations for beginners, intermediate learners, and experts, as well as courses that focus on specific topics within computer engineering, like computer architecture and operating systems.
FPGA Design for Embedded Systems Specialization
Provider: University of Colorado Boulder
This hands-on program equips you with the skills to design and implement complex electronic systems using FPGAs.
Kick off with “Introduction to FPGA Design for Embedded Systems,” where you’ll unravel the basics of FPGA technology.
You’ll learn to select the appropriate FPGA architecture for various applications and navigate through cutting-edge development tools.
Remember, you’ll need a Windows or Linux-based PC with at least 8 GB of RAM to get started.
Move on to “Hardware Description Languages for FPGA Design,” where VHDL and Verilog become your tools of the trade.
This course breaks down complex concepts into digestible chunks, ensuring you build a solid foundation in these critical hardware description languages.
In “FPGA Softcore Processors and IP Acquisition,” you’ll delve into soft processors and IP within FPGAs.
You’ll craft your own soft processor, integrate IP blocks, and validate your designs using tools like ModelSim for simulation.
The finale, “FPGA Capstone: Building FPGA Projects,” is where theory meets practice.
You’ll need a DE10-Lite development kit to design, test, and debug actual FPGA projects.
By the end of this course, you’ll have a comprehensive understanding of the FPGA development flow, from conception to implementation.
Throughout this specialization, you’ll gain proficiency in digital design, simulation verification, and software design for softcore processors.
You’ll also become adept at using Quartus Prime for programming and debugging, and you’ll familiarize yourself with the Nios II soft processor and various peripherals.
Arm Cortex-M Architecture and Software Development Specialization
Provider: Arm
This series of courses guides you from a basic understanding to advanced proficiency in Arm Cortex-M processors, making it ideal for both beginners and those looking to deepen their knowledge.
The journey begins with “Arm Cortex-M Processors Overview,” a course designed for newcomers.
It introduces you to the world of Arm processors, explaining the architecture’s history and the differences between its profiles.
You’ll also discover where to find essential resources and support for Cortex-M projects.
This foundational course sets the stage for more technical exploration.
Moving forward, “Armv8-M Architecture Fundamentals” dives into the specifics of the Armv8-M architecture, relevant to modern Cortex-M processors like the Cortex-M33 and Cortex-M55.
You’ll gain insights into the programming model, standards, and APIs, alongside practical skills in assembly language programming.
This course remains valuable even for those working with older processor versions, highlighting its broad applicability.
In “Cortex-M Software Development Fundamentals,” the focus shifts to software development.
Here, you’ll learn to optimize software using Arm C/C++ compilers and debug tools, targeting either performance or code size.
The course also covers the Common Microcontroller Software Interface Standard, ensuring a consistent approach to writing software for Cortex-M devices.
It’s crucial for mastering how to compile, link, debug, and trace Cortex-M applications.
Finally, “Advanced Armv8-M Features” explores the Cortex-M system’s advanced and optional features, such as security and performance enhancements.
This course allows you to select topics that match your project needs, offering a customizable learning experience.
Build a Modern Computer from First Principles: From Nand to Tetris (Project-Centered Course)
Provider: Hebrew University of Jerusalem
If you’re looking for a course that will take you from the principles of computing to the creation of complex systems, this is it.
This course is a hands-on adventure that guides you from the ground up, starting with the simplest logic gate, the Nand, and culminating in the creation of the classic game Tetris on a computer you build yourself.
You’ll begin with an introduction to the course structure and objectives, setting a clear path for your adventure.
In Unit 1, you’ll tackle Boolean Logic, learning to manipulate logic gates and express hardware functions using Hardware Description Language.
This sets the foundation for creating complex circuits.
Unit 2 shifts your focus to the arithmetic that powers computing.
You’ll master binary numbers and operations, and construct an Arithmetic Logic Unit (ALU), a critical component for performing calculations within a computer.
As you progress to Unit 3, you’ll delve into Sequential Logic, where you’ll understand how computers store and recall information.
You’ll build essential memory units, learning about flip flops and counters.
Unit 4 introduces you to Machine Language.
You’ll learn how to communicate with the Hack Computer, a simple yet powerful model you’ll use to understand computer instructions and programming.
In Unit 5, the course explores Computer Architecture.
You’ll examine the Von Neumann Architecture and the Fetch-Execute Cycle, gaining insights into the Central Processing Unit (CPU) and how it processes instructions.
Finally, Unit 6 demystifies Assembly Languages and Assemblers.
You’ll get hands-on experience with the Hack Assembly Language and develop an assembler, bringing together all the components of your computer.
Throughout the course, you’ll engage in projects that reinforce your learning, allowing you to apply theoretical knowledge in practical scenarios.
By the end of the course, you’ll not only have a deep understanding of how computers work but also have the satisfaction of having built one from scratch.
This course stands out because it’s project-centered, ensuring that you learn by doing.
Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course)
Provider: Hebrew University of Jerusalem
This course isn’t just about reading and watching; it’s about doing.
You’ll get your hands dirty with real projects that take you from understanding machine language to building an entire operating system.
You’ll start with the basics of machine language, learning how to communicate with the Hack Computer.
This foundational knowledge will set the stage for everything that follows.
As you progress, you’ll tackle the Virtual Machine (VM) abstraction, mastering the stack and memory segments, and using a VM emulator to see your code in action.
The course then guides you through the intricacies of program control, branching, and functions.
You’ll learn to write programs that can make decisions and execute complex tasks, culminating in the completion of your VM Translator.
Next, you’ll get acquainted with the Jack programming language, diving into object-based programming and app development.
You’ll even optimize graphics, ensuring your applications aren’t just functional but also efficient and visually appealing.
Moving forward, you’ll delve into syntax and lexical analysis, constructing a syntax analyzer to bridge the gap between the Jack language and the VM.
This is where your understanding of programming languages deepens, as you translate high-level code into VM instructions.
In the final stretch, you’ll focus on code generation, managing variables, expressions, and program flow.
You’ll handle objects and arrays, and apply your skills to map your code onto the VM you’ve become familiar with.
The climax of the course is the creation of your own operating system.
You’ll tackle complex tasks like heap management, graphics, and string processing.
By the end of the course, you’ll have a comprehensive understanding of how software and hardware interact, having built a computer system from the ground up.
This course is designed for you to apply what you learn immediately through hands-on projects.
By the time you finish, you’ll not only have theoretical knowledge but also practical experience in computer engineering.
Computer Architecture
Provider: Princeton University
You’ll start with the foundations of architecture and microarchitecture, understanding the blueprint of a computer’s brain.
You’ll learn about machine models and ISA characteristics, which are like the DNA of computer languages.
Next, you’ll tackle pipeline basics, learning how computers process tasks efficiently.
You’ll navigate through potential pitfalls like data hazards and control hazards, ensuring smooth operation.
Caches come into play as you discover how to speed up access to data.
You’ll delve into the intricacies of cache performance, learning to optimize this crucial component of computer speed.
The course then introduces you to superscalar processors, where you’ll manage multiple processing units to boost performance.
You’ll also get to grips with out-of-order processors, which rearrange tasks for optimal efficiency.
Advanced topics like VLIW and predication will challenge you to enhance instruction execution, while branch prediction teaches you to improve a computer’s decision-making process.
You’ll also focus on optimizing caches, managing memory with techniques like TLB processing, and harnessing the power of vector processors for high-performance tasks.
In the latter part of the course, you’ll explore parallelism and consistency, essential for collaborative computing.
You’ll dive into GPUs for graphics processing and SMT for high-level multitasking.
Throughout the course, problem sets will test your knowledge, applying concepts like cache coherence, SIMD, and interconnection networks to real-world scenarios.
By the end of this course, you’ll have a deep understanding of computer architecture, from microcoded microarchitecture to the scalability of directory coherence.
How Computers Work
Provider: University of London
This course is designed to demystify the inner workings of computers in a way that’s easy to grasp.
You’ll begin with the essentials of computer science, focusing on abstraction to simplify complex concepts.
This helps you understand how computers process data without getting overwhelmed by technicalities.
The course introduces you to notional machines, a conceptual tool that simplifies the understanding of a computer’s operations.
You’ll also delve into the roles of the CPU and memory, the core components that power every computer.
As you progress, the course reveals the “deep secret” of computer science, which is the management of states, or the various conditions a computer can be in.
Practical examples, like an e-commerce site, illustrate these concepts in action.
You’ll even learn why rebooting a computer can solve many issues.
You’ll tackle the organization of files, the importance of modularity in breaking down complex problems, and the intricacies of applications.
Debugging skills are also covered, equipping you with the ability to troubleshoot and solve coding problems effectively.
Networking and internet modules explain how computers communicate, while security sessions address threats and encryption, ensuring you understand how to protect information.
An expert interview with Sarah Wiseman offers deeper insights into password security.
The course also covers the technicalities of websites, including their structure, the interaction between clients and servers, and the use of APIs for software communication.
You’ll learn about the significance of your data on the web and how it’s managed.
Each section concludes with a summary to reinforce your learning, and additional resources are provided for those eager to delve deeper.
Computer and Peripheral Hardware
Provider: Illinois Tech
This course offers a comprehensive dive into the essentials of computer hardware, providing you with a clear understanding of the components that power computers.
Starting with the motherboard, the course breaks down its role as the central hub of a computer.
You’ll learn about BIOS and UEFI, the systems that boot up your computer, and how to use CPU-Z to analyze hardware performance.
As you progress, the course covers the Central Processing Unit (CPU), explaining its function as the computer’s brain.
You’ll understand the significance of CPU sockets, the transition from 32-bit to 64-bit computing, and the advantages of multi-core processors for advanced tasks.
Power is also a key focus, with the Power Supply Unit (PSU) and Ohm’s Law demystified, ensuring you grasp how electricity fuels a computer.
In terms of memory and storage, the course navigates through RAM, cache, and hard disk drives, introducing you to faster storage technologies like NVM Express.
You’ll also delve into RAID configurations for improved performance and data security.
Network-attached Storage and Small Computer System Interface (SCSI) are also covered, giving you insights into data accessibility and management.
Throughout the course, you’ll engage in assessments to solidify your understanding, culminating in a summative course assessment that encapsulates all you’ve learned.
By the end of this course, you’ll have a robust knowledge of computer hardware, positioning you to confidently discuss, build, or troubleshoot computers.
Introduction and Programming with IoT Boards
Provider: Pohang University of Science and Technology(POSTECH)
This course stands out by offering a practical, hands-on approach to understanding and creating IoT devices.
Starting in week one, you’ll grasp the essentials of IoT, learning about its significance and starting discussions that will expand your perspective.
In week two, the focus shifts to communication protocols, essential for IoT device interaction.
You’ll gain insights into how these devices exchange information, setting the stage for more complex concepts.
Week three is intensive, with six sessions dedicated to programming IoT boards.
You’ll write actual code, which is like teaching devices to perform tasks autonomously.
By week four, you’re piecing everything together, exploring how to enhance IoT devices with decision-making capabilities.
This knowledge is crucial for creating smart, responsive technology.
The course concludes in week five, where you refine your projects and solidify your understanding of IoT systems.
Throughout the course, active programming and weekly discussions ensure that you’re not just passively absorbing information but are engaging with the material and your peers.
Cyber-Physical Systems: Modeling and Simulation
Provider: University of California, Santa Cruz
This course dives into the essential elements of cyber-physical systems, which are the complex networks that integrate computation with physical processes.
From the get-go, you’ll learn to model these systems, both in discrete-time, which updates at set intervals, and continuous-time, which changes without breaks.
You’ll become skilled in using MATLAB and Simulink, essential tools for engineers to test their models virtually.
You’ll also gain a deep understanding of finite-state machines, the decision-makers within cyber-physical systems.
Through hands-on simulations, you’ll apply these concepts to real-life scenarios, like managing a room’s temperature or strategizing a chess game.
Homework assignments are designed to reinforce your learning and ensure you’re absorbing the material.
You’ll delve into digital communication networks and learn the intricacies of converting between analog and digital signals.
As the course progresses, you’ll tackle hybrid systems that blend continuous and discrete elements.
You’ll use specialized tools like the Hybrid Equations Toolbox to simulate even the most complex cyber-physical systems.
Embedded Software and Hardware Architecture
Provider: University of Colorado Boulder
This course offers a deep dive into the essentials of microcontroller technology and the intricate dance between software and hardware.
You’ll start by mastering the architecture-software interface, which is crucial for understanding how your computer processes and executes tasks.
You’ll also tackle word size and data types, the fundamental elements that define how your computer stores and handles information.
Pointers and memory interaction are next on the list, teaching you how to direct your computer’s operations with precision.
You’ll learn about memory alignment and endianness, ensuring that you can manage how your computer reads and stores data efficiently.
The course also demystifies compiler attributes and guides you through creating a memory map and understanding registers.
This is like getting a blueprint of your computer’s internal workings.
When it comes to hardware, you’ll get hands-on with memory access and manipulation, bit manipulation, and IO port configuration.
These skills are essential for fine-tuning how your computer interacts with external devices.
You’ll also develop the ability to create software interfaces for hardware, enabling seamless communication between your computer and attached peripherals.
Advanced pointer use and function pointers will empower you to orchestrate complex operations with ease.
Debugging is a critical skill you’ll hone, learning to troubleshoot microcontroller programs effectively.
This ensures you can identify and fix issues quickly, keeping systems running smoothly.
Data structures are another key focus, where you’ll explore enumerations, unions, structures, and encapsulation.
You’ll also work with bit fields, LIFO buffers, circular buffers, and linked lists, all tools for organizing and managing data effectively.
Digital Systems: From Logic Gates to Processors
Provider: Universitat Autònoma de Barcelona
This comprehensive course takes you from the ground up, starting with the binary system and pseudocode, the ABCs of computer language.
You’ll then progress to the heart of digital systems, learning how to describe and construct them.
The course covers digital electronic systems, processors, and program examples, giving you a clear view of the inner workings of modern technology.
As you advance, the course introduces you to combinational circuits and Boolean Algebra, the core logic behind computing.
You’ll get hands-on experience with logic gates like NAND and NOR, and learn how to specify and structure circuits.
Tools such as VerilUOC_Desktop and Logisim are provided to help you visualize and experiment with digital concepts.
This practical approach ensures you’re not just memorizing theory but actually understanding how things work.
The course also delves into VHDL, a specialized language for describing digital systems.
You’ll learn to write precise instructions that dictate how a system operates, both sequentially and concurrently.
Moving deeper, sequential circuits come into play, essential for functions like memory and processing.
You’ll explore the synthesis of these circuits and the design of combinational and sequential blocks.
Towards the end, the focus shifts to the implementation of algorithms, registers, counters, and memories.
You’ll also encounter finite state machines, the decision-makers within digital systems.
The final lessons cover the physical implementation, including synthesis tools and testing methods, ensuring you’re equipped to bring your digital designs to life.
With a mix of PDF materials, solved exercises, and a supportive forum, this course provides a rich learning environment.
Introduction to Architecting Smart IoT Devices
Provider: EIT Digital
This course offers a comprehensive journey through the essentials of embedded systems, the powerhouse of smart technology.
You’ll start by understanding the evolution and significance of embedded systems in today’s tech-driven markets.
Grasping real-time system concepts is crucial, and you’ll learn exactly why, delving into the intricacies of how these systems need to respond instantaneously.
The course demystifies complex principles like Shannon’s Principle and introduces you to the world of Commercial Off-The-Shelf (COTS) components, which can significantly streamline the development process.
You’ll also get to grips with execution models such as parallel processing and multithreading, which are vital for high-performance smart devices.
Timing is everything in IoT, and you’ll explore various time-related concepts, ensuring your devices can synchronize and function effectively in real-world scenarios.
But it’s not just about building; it’s about understanding potential pitfalls.
You’ll study real-world failures, from the infamous Stuxnet virus to the Mars Pathfinder mission, learning how to identify and mitigate risks in embedded systems.
The course also guides you through the decision-making process of building versus buying components, addressing the complexities of software size with Source Lines of Code (SLOC), and considering the implications for team dynamics.
In the third module, the focus shifts to the lifecycle of smart device development.
You’ll dive into architectural design and Model-Based Design, employing the Systems Modeling Language (SysML) to visualize and manage system complexities.
You’ll learn how to gather both functional and non-functional requirements, ensuring your design aligns with user needs and system specifications.
The course introduces design patterns and contrasts CASE tools with Integrated Development Environments (IDEs), equipping you with the knowledge to choose the right tools for your projects.
By installing a SysML tool and studying “SysML Distilled,” you’ll gain hands-on experience that solidifies your understanding of system modeling.
Also check our posts on: