Skip to content

Latest commit

 

History

History
1445 lines (1015 loc) · 114 KB

README.md

File metadata and controls

1445 lines (1015 loc) · 114 KB
Raw

Embedded Systems Engineering Roadmap

GitHub Repo stars GitHub forks GitHub watchers GitHub contributors GitHub tag (with filter) GitHub release (by tag) GitHub all releases

This roadmap is designed to help beginners aspiring to build a career as an Embedded Engineer/Developer, as well as assist current practitioners in expanding their skills.

Embedded engineering demands a solid understanding of hardware functionality as well as software development and programming skills. If you really want to pursue this career you must be highly motivated and passionate about it. As the well-known saying goes, "Hardware is hard!". But don't panic and be patient for the challenges you may encounter along this exciting journey. By dedicating enough time and effort practicing and doing projects you will soon find yourself as a real embedded engineer! 😀

❓ What is an Embedded System?

▶️ ISO/IEC/IEEE 24765 Standard:

computer system that is part of a larger system and performs some of the requirements of that system. For example, a computer system used in an aircraft or rapid transit system.

The hardware and software of an embedded system are usually minimized and optimized for specific functions. The embedded system includes at least one microcontroller, microprocessor or digital signal processor. The embedded system designed to optimize reliability, cost, size and power saving for applications.

▶️ "Making Embedded Systems" Book:

An embedded system is a computerized system that is purpose built for its application.

▶️ "Computer Organization and Embedded Systems" Book:

A physical system that employs computer control for a specific purpose, rather than for general-purpose computation, is referred to as an embedded system.

▶️ Analog Devices Glossary:

An embedded system is a system in which the computer (generally a microcontroller or microprocessor) is included as an integral part of the system.

Often, the computer is relatively invisible to the user, without obvious applications, files, or operating systems. Examples of products with invisible embedded systems are the controller that runs a microwave oven or the engine control system of a modern automobile.

▶️ Embedded Systems Glossary:

A combination of computer hardware and software, and perhaps additional mechanical or other parts, designed to perform a dedicated function.

In some cases, embedded systems are part of a larger system or product, as in the case of an antilock braking system in a car.

🗺️ The Roadmap

Embedded Systems Engineering Roadmap

The embedded systems engineering roadmap is structured into three fundamental areas: SOFTWARE, HARDWARE, and SOFT SKILLS.

While the intersection of hardware and software is prevalent in embedded systems, specific job titles tend to emphasize one aspect over the other. For instance, roles like "Embedded Software Engineer/Developer," "Firmware Engineer/Developer," and "Embedded Linux Engineer/Developer" predominantly focus on software development. In contrast, positions such as "Embedded Hardware Engineer" and "Hardware Design Engineer" primarily deal with hardware design and electronics. Moreover, there are roles like "Embedded Systems Engineer" that necessitate a comprehensive understanding of both hardware and software.

It's crucial to note that each company in the embedded industry may have unique requirements for a given job title. Therefore, it's essential to tailor your focus based on your career aspirations. If you're seeking an embedded software position, prioritize the software-related skills outlined in the roadmap. Conversely, if you're interested in an embedded hardware job, concentrate on hardware skills and dedicate more time to learning electronics.

The roadmap provides a comprehensive guide to the essential topics for a typical "Embedded Systems Engineer" role. By delving into both software and hardware aspects, you can develop the necessary skills to thrive in this dynamic field. However, if you have a clear preference for software or hardware, you can tailor your learning path accordingly.

Note

Remember that the importance of individual software and hardware skills can differ depending on the specific requirements of the company and the job role.

Tip

To differentiate between the types of learning resources and the quality of their content, specific symbols are used before each item.

Resource types:

  • 📘 : Books
  • 🎞️ : Videos
  • 📝 : Write-ups, articles, and blog posts
  • 🔗 : Other links that do not fit into any of the above categories

Content quality symbols:

  • 👶 : Easy-to-understand and beginner-friendly resources. Refer to them if you do not have prior knowledge in a topic.
  • 💎 : Well-known references that have truly invaluable and comprehensive content. Refer to them if you want to deepen your understanding of a topic.

😕 Don't Know Where to Start!

If you feel overwhelmed by the extensive list of topics in the roadmap, you're not alone. Before delving too deeply, let's ease into it with some simple starter projects. Learning embedded systems engineering takes time and effort. Don't get discouraged if you don't understand something right away. Keep practicing and you will eventually get there.

⚒️ Projects

Engaging in hands-on projects is the most effective approach to learning. Rather than solely relying on theoretical knowledge from books or articles. Undertaking projects allows for practical learning experiences. Even a seemingly basic project has the potential to teach you more than hours of aimless reading. You can refer to books, articles, and courses when faced with difficulties in understanding the problems in real-world projects.

Don't try to build a complex project right away. Start with small, manageable projects to get your feet wet.

🔎 Search and Ask!

Use search engines to find the answers to your questions.

If you can't find what you're looking for using search engines, AI chatbots can also provide assistance. Keep in mind that AI may provide incorrect answers in some cases. It's best to confirm any answers with more reliable references.

If you have reservations about relying on AI advice alone, you can also ask your questions from real people:

🎥 Courses and YouTube Contents

You may have heard that YouTube is a university. And it's true - there is an extensive amount of invaluable free content on embedded systems available on YouTube. You'll also find some excellent free courses through Coursera and EdX. Additionally, Udemy offers some high-quality paid course options.

🕹️ Arduino

If you do not have any background in programming the embedded systems, Arduino boards and libraries are the best choice for you to start and learn the basics. Just keep in mind that most of the Arduino libraries are developed for learning purposes and are not optimized to be used in industry.

Additionally, the Arduino Core takes care of most of the low-level hardware-associated operations that you, as an embedded engineer, should be able to handle yourself or at least have a clear understanding of. If you want to become a professional embedded developer, you should be able to effectively use industry-standard APIs and SDKs provided and approved by microcontroller vendors, such as CMSIS for ARM Cortex-M microcontrollers, STM32Cube for STM32, ESP-IDF for Espressif microcontrollers, etc.

👨‍🏫 Educational Websites

🗺️ Other Helpful Roadmaps

🛠️ IDEs

👨‍💻 VS Code Extensions

🐜 PlatformIO

PlatformIO is a cross-platform, cross-architecture, multiple framework, professional tool for embedded systems engineers and for software developers who write applications for embedded products.

PlatformIO is not yet extensively adopted in industrial and large-scale projects, however, it is an excellent choice for individuals working on smaller projects. This is because it greatly reduces the need to install frameworks and setup build and debug tools, allowing you to concentrate on programming.

📚 Learning Resources

Warning

It is not necessary to read all the books, articles, or watch all the videos you see here. If you try to do so, you will finally get tired and disappointed. You cannot study all the available content here in a reasonable time because it may take years. It is important to study enough to have at least a basic understanding of the required topics. Of course, the more time you dedicate to studying and doing projects, the more profound your knowledge and expertise will become.

Some of the resources mentioned here will just be used as references. Refer to them only when you need them.

✳️ Soft Skills

Similar to other professions, embedded engineers require soft skills that can't be solely obtained from reading or watching videos. These skills are cultivated through interactions and tackling various work obstacles. Improving soft skills is not a one-size-fits-all approach. It will vary based on one's individual traits and requires self-awareness of your strengths and areas for growth. Enhancing these skills takes time and effort.

✳️ Electronics

🔵 Basic Math & Calculus

🔵 Principles of Electric Circuits

🔵 Electronics Fundamentals

🔵 Digital Design

🔵 Computer Architecture

Computer architecture is the backbone of embedded systems, governing the hardware and software interactions. Embedded developers need a grasp of computer architecture to design, develop, and debug embedded software effectively. Expertise in ARM and RISC-V, two prevalent instruction set architectures (ISAs) in embedded systems, is paramount for embedded developers. ARM is the dominant ISA, while RISC-V's open-source nature and flexibility are gaining traction.

✳️ Using Test Equipment

Embedded systems often require specialized test equipment to verify their functionality and performance. This equipment includes multimeters, oscilloscopes, logic analyzers, function generators, power supplies, and other tools that allow engineers to measure signals, inject stimuli, and monitor the behavior of embedded systems.

🔵 Multimeter

🔵 Logic / Protocol Analyzer

🔵 Oscilloscope

✳️ Prototyping Skills

While hardware design and prototyping are primarily the responsibility of electronic hardware design engineers, embedded software engineers can benefit from a basic understanding of these concepts. This knowledge can be instrumental in identifying and resolving hardware-related issues during embedded system debugging. By having a grasp of hardware principles, embedded software engineers can effectively pinpoint the root causes of problems, leading to quicker and more efficient troubleshooting.

🔵 Breadboarding

Breadboarding is a hands-on approach to prototyping circuits, providing a versatile platform for experimentation and circuit design. Embedded systems often utilize breadboards for their ease of use, flexibility, and cost-effectiveness. By connecting components on a breadboard, embedded systems developers can quickly test and refine their designs without the need for permanent soldering. This allows for rapid iterations and efficient debugging, making breadboarding an invaluable tool for embedded system development.

🔵 Hardware Design Basics

🔵 PCB Design / EMC

🔵 Soldering / Rework

✳️ FPGA Development

FPGAs (Field-Programmable Gate Arrays) are specialized integrated circuits that can be configured to perform various digital logic functions. They are widely used in embedded systems to achieve high performance, flexibility, and cost-effectiveness. FPGA designers use hardware description languages (HDLs) to create customized circuits that map directly to the FPGA architecture. Since FPGA engineering and verification differ significantly from embedded software development, it stands as a specialized domain within embedded systems.

✳️ Programming Fundamentals

Mastering programming fundamentals and software development principles is essential for a successful embedded design. Embedded systems demand efficient code, optimized data management, reusable design patterns, and effective memory management to function effectively in resource-constrained environments. Embedded developers must possess a strong foundation in these core concepts to create reliable and performant embedded systems.

🔵 Algorithms & Data Structures

🔵 Design Patterns

🔵 State Machines

🔵 Memory Management

✳️ Programming Languages

Low-level languages like C and assembly provide direct hardware access, enabling efficient code optimization for resource-constrained embedded systems. System-level languages like C++ and Rust offer a higher level of abstraction for complex embedded applications, while Python is often employed for testing embedded systems due to its simplicity.

🔵 C

🔵 C++

🔵 Assembly

🔵 Python

🔶 Python for Microcontrollers

🔵 Rust

🔵 Zig

✳️ Microcontrollers

Microcontrollers are integrated circuits (ICs) that combine a microprocessor, memory, and input/output (I/O) peripherals on a single chip. They are designed for embedded applications, where they are used to control devices in a variety of industries, including automotive, industrial, consumer electronics, and healthcare.

Some popular microcontroller families include AVR, PIC, STM32, MSP430, nRF, and ESP32. Choosing the right microcontroller involves assessing application requirements, processing power, memory needs, and input/output capabilities. Consider ease of use, cost, reliability, availability, and future expansion.

🔵 GPIO

🔵 ADC

🔵 DAC

🔵 Timers / Counters

🔵 PWM (Pulse Width Modulation)

🔵 RTC (Real Time Clock)

🔵 Watchdog

🔵 Interrupts

🔵 DMA

🔵 Clock Management

🔵 Power Management

🔵 Bootloader / DFU (Device Firmware Update)

✳️ Interfaces, Protocols & Communication Technologies

Embedded systems often communicate with other devices or external systems via interfaces, protocols. Interfaces provide the physical connections, protocols define data exchange rules. The choice depends on application-specific needs, including bandwidth, distance, security, and power consumption.

🔵 ‌Basic Protocols

🔶 UART
🔶 I2C
🔶 SPI
🔶 SDIO
🔶 I3C
🔶 1-Wire

🔵 Digital Audio Protocols

🔶 I2S
🔶 PCM

🔵 Display & Camera Protocols

🔶 MIPI CSI-2
🔶 MIPI DSI
🔶 HDMI

🔵 Wireless Protocols

🔶 Bluetooth / BLE
🔶 Wi-Fi
🔶 LoRa / LoRaWAN
🔶 Zigbee
🔶 Thread
🔶 Matter

🔵 Industrial Protocols

🔶 Modbus
🔶 RS485
🔶 EtherCAT
🔶 CoAP & MQTT

🔵 High-Speed Protocols

🔶 Ethernet
🔶 USB
🔶 PCIe

🔵 Automotive Protocols

🔶 CAN

🔵 Network Protocols / Socket Programming

🔵 Cellular Communication

🔶 GSM / LTE
🔶 LTE-M & NB-IoT

✳️ Memory Technologies & File Systems

Embedded systems employ a combination of volatile (SRAM, DRAM, PSRAM) and non-volatile (flash, EEPROM, FRAM) memory to store and access data, based on factors like performance, cost, power consumption, and durability.

🔵 Flash Memory

🔶 NOR / NAND
🔶 eMMC
🔶 SD Card

🔵 EEPROM

🔵 SRAM / DRAM

🔵 File Systems

A file system is a way of organizing data on a storage device, such as a hard drive, flash drive, or solid-state drive. It provides a way to store, access, and manage files, which are collections of data that can be accessed individually. File systems in embedded systems are typically lightweight and optimized for efficiency, considering the limited resources and specific requirements of embedded devices. They often employ simpler file structures and data structures compared to desktop or server file systems.

✳️ Hardware Simulation / Emulation

Embedded system development often involves simulating or emulating hardware environments to test and debug software before deploying it on actual hardware. Simulation tools create virtual models of hardware systems, while emulation tools replicate the actual hardware behavior using real hardware components. These tools offer several advantages, including reducing development time, minimizing hardware costs, and enhancing software reliability.

🔵 QEMU

🔵 Renode

✳️ Sensors & Actuators

Sensors and actuators are the eyes and hands of embedded systems. They are responsible for gathering information about the environment and taking actions based on that information. Sensors convert physical phenomena, such as temperature, light, or sound, into electrical signals that can be processed by the embedded system. Actuators, on the other hand, convert electrical signals into physical actions, such as controlling the speed of a motor or opening and closing a valve.

🔵 Sensors

🔵 Actuators

✳️ Digital Signal Processing

Digital signal processing (DSP) is a branch of engineering that deals with the processing of digital signals. It is used in a wide variety of applications, including embedded systems, communication systems, and multimedia systems. DSP algorithms are often implemented in hardware using application-specific integrated circuits (ASICs) or field-programmable gate arrays (FPGAs).

🔵 DSP Basics & Filter Design

🔵 Discrete Fourier Transform / FFT

✳️ Control Theory

🔵 PID Controller

🔵 MATLAB / Simulink

✳️ Operating Systems

Embedded systems can be programmed with either an operating system (OS) or directly on the hardware, known as bare-metal programming. Each approach has its own advantages and disadvantages. Embedded operating systems provide a layer of abstraction between the hardware and the application code, offering benefits like resource management, task scheduling, error handling, and communication capabilities. However, they add overhead and may not be suitable for memory-constrained applications.

🔵 Operating System Fundamentals

🔵 Real-Time Operating Systems

Real-time operating systems (RTOS) are specialized operating systems designed to meet strict timing deadlines. They are used in embedded systems where timing is critical, such as avionics, robotics, and medical devices. RTOSs provide a deterministic environment in which tasks can be executed with predictable timing. This ensures that critical tasks are always executed on time, even in the presence of interrupts and other disruptions.

🔶 RTOS Basics
🔶 FreeRTOS
🔶 Zephyr
🔶 μC/OS / Micriμm OS
🔶 NuttX
🔶 RT-Thread
🔶 Mbed OS
🔶 QNX
🔶 VxWorks
🔶 Azure RTOS (ThreadX)

🔵 Embedded Linux

Embedded Linux is a specialized version of the Linux operating system tailored for embedded systems. It's designed to operate on devices with resource constraints, such as limited memory, processing power, and power consumption.

🔶 Linux Kernel
🔶 Linux Device Drivers
🔶 U-Boot
🔶 Buildroot
🔶 Yocto
🔶 Multithreading & Parallel Processing
🔶 High-Performance Computing (HPC)
🔶 Inter-Process Communication (IPC)
🔶 Qt Framework

✳️ Debugging

Debugging embedded systems involves identifying and resolving software defects and hardware malfunctions. Various techniques are employed to pinpoint the root causes of issues, such as static code analysis, dynamic analysis, simulation and emulation, in-circuit debugging, and hardware debugging.

🔵 JTAG / SWD

JTAG and SWD (Serial Wire Debug) are two popular interface protocols used for debugging and programming embedded systems. JTAG is a more general-purpose protocol that can be used to debug and program a wider range of devices, while SWD is a simpler and more compact protocol that is specifically designed for ARM microcontrollers.

🔵 GDB

GDB (GNU Debugger) is a powerful and versatile debugger for source-level and machine-level debugging. It supports a wide range of programming languages, including C, C++, Objective-C, Java, and Rust. GDB is a free and open-source software tool that is widely used by developers and researchers.

🔵 OpenOCD

OpenOCD (Open On-Chip Debugger) is an open-source software tool that provides a powerful and versatile platform for debugging and programming embedded systems. It serves as an interface between a hardware debug adapter (HDA) and a debugger, such as GNU Debugger (GDB), enabling developers to interact with the target microcontroller or microprocessor. OpenOCD supports a wide range of hardware platforms and provides a comprehensive set of features for hardware debugging, programming, and boundary-scan testing.

✳️ Build System

Build systems automate the process of compiling and linking source code into executable programs. They are essential tools for software development, as they can help to improve the efficiency and consistency of the build process. Popular build systems include Make, and CMake.

🔵 Compilers / GCC

GCC (the GNU Compiler Collection) is a free and open-source compiler system that can compile programs for many different programming languages, including C, C++, Objective-C, Fortran, Ada, and Go. GCC is a popular choice for embedded systems development due to its open source nature, maturity, stability, portability, performance, and large community. On the other hand proprietary compilers like Keil and IAR offer toolchain support, target-specific optimizations, and customer support, which may be preferred for specific projects.

🔵 Make / CMake

CMake and Make are both tools for building software applications. CMake is a meta-build system that generates Makefiles, which are then used by Make to build the software. CMake is more versatile and cross-platform than Make, and it is becoming the more popular choice for modern software development.

🔵 Bash Scripting

Bash scripting serves as a powerful tool in embedded systems development, enabling developers to automate repetitive tasks, handle complex configurations, and manage the embedded system's environment effectively. Bash scripting is a Linux-specific tool that is not natively integrated into Windows. However, it can be accessed via the Windows Subsystem for Linux (WSL).

🔵 Docker

Docker containers provide a consistent and isolated environment for building software applications. This can help to improve the reproducibility of builds and reduce the risk of errors. Docker also makes it easier to share build environments, which can save time and effort for developers.

✳️ Software Development Life Cycle (SDLC) Models

Software Development Life Cycle (SDLC) models provide a structured approach to software development, guiding the process from planning to deployment and maintenance. These models provide a framework for organizing, managing, and executing software projects, ensuring a consistent and efficient development process.

🔵 Agile / SCRUM

🔵 V-Model (V-cycle)

✳️ Version Control Systems

Version control systems are essential tools for managing changes to code and other digital assets. They track changes over time, allowing developers to revert to previous versions, collaborate effectively, and identify potential conflicts. Popular version control systems include Git, Mercurial, and Subversion.

🔵 Git

🔵 SVN (Subversion)

✳️ Testing

Testing is an integral part of the embedded systems development process, ensuring the quality, reliability, and safety of these systems. It involves a range of techniques, from unit testing to system testing, to validate the functionality and performance of the software and hardware components.

🔵 Test Driven Development (TDD)

🔶 Unit Testing
🔸 GoogleTest - Google Testing and Mocking Framework
🔶 Integration Testing

🔵 CI/CD Pipelines

Continuous Integration (CI) and Continuous Delivery (CD) are software development practices that automate the process of building, testing, and deploying software. CI/CD pipelines are designed to ensure that software changes are deployed quickly and reliably.

🔵 SIL / HIL Testing

Software-in-the-loop (SIL) and hardware-in-the-loop (HIL) testing are two crucial techniques used in embedded systems development to validate the functionality and performance of software before it is deployed on real hardware. These testing methods simulate the real-world environment of the embedded system using software models or hardware emulators.

🔵 Standards & Certifications

Embedded systems development is subject to a variety of standards and certifications, which serve as guidelines and benchmarks for ensuring the quality, safety, and reliability of these systems. These standards are often developed and maintained by industry bodies, such as the International Electrotechnical Commission (IEC) and the Society of Automotive Engineers (SAE).

🔶 Functional Safety

✳️ Embedded Security

Security in embedded systems is particularly challenging due to resource constraints and the inherent nature of these devices. Embedded systems typically operate on small, low-power microcontrollers with limited memory and processing power. This makes it difficult to implement the same level of security as traditional computing platforms. Additionally, embedded systems often have limited access to updates and patches, making them more vulnerable to known vulnerabilities.

🔵 Hardware Hacking

Learning hardware hacking helps security professionals understand how embedded systems can be compromised and develop effective defenses against cyberattacks. This knowledge enhances the resilience of embedded devices to attack.

🔵 Cryptography

🔵 Secure Boot & Secure Firmware Update

✳️ Embedded GUI

Graphical User Interfaces (GUIs) have become an indispensable part of modern embedded systems, offering a user-friendly and intuitive way to interact with devices. Designing effective GUIs for embedded systems requires careful consideration of factors such as resource constraints, user experience, and real-time performance.

✳️ IoT (Internet of Things)

The Internet of Things (IoT) refers to a network of interconnected devices, which gather and exchange data with other devices or with the cloud. Embedded systems are typically the "brains" of IoT devices, managing data collection, processing, and communication tasks. Embedded systems are designed to operate with limited power and resources, making them well-suited for IoT applications.

🔵 Delta Over-The-Air Firmware Update

✳️ Edge AI

Edge AI refers to the ability of devices to perform machine learning tasks on their own, without the need to send data to a central server. This can be done by using small, specialized AI models that are embedded directly into the device. TinyML is a subset of Edge AI that focuses on developing these models for devices with very limited computing power, such as microcontrollers and sensors.

🔵 AI & ML Basics

🔵 TensorFlow Lite

🔵 TinyML

✳️ AUTOSAR Architecture

AUTOSAR, or AUTomotive Open System ARchitecture, is a global industry standard for automotive software development. It is a software architecture that provides a standardized platform for developing and integrating software components in vehicle electronic control units (ECUs). This allows different ECUs from different manufacturers to communicate and work together seamlessly.

History

At first this was meant to be my personal reading list but as the list gradually became bigger and bigger, I wondered why not share it with others. So I did research on current job postings for embedded engineering roles, selecting the most frequent skills and including them on a roadmap. In order to make the roadmap more comprehensive I also added some basic skills and finally came up with what you see here.

The idea of creating this roadmap came from vazeri / Embedded-Engineering-RoadMap-2018 which was well designed but had some flaws and not updated for years. I took that idea, changed the structure of the roadmap and tried to improve it. The initial results can be accessed in m3y54m / Embedded-Engineering-Roadmap-Archived which is now archived. Early versions of the roadmap were created using Balsamiq Wireframes which is not suitable for these types of diagrams. So I decided to use Microsoft Visio instead and redrew the whole diagram.

Copyright

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License which means that you are free to share or adapt this work under the following terms:

Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.

ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.

Acknowledgement

Special thanks to my friends in the community of Iranian Embedded Engineers in Twitter and r/embedded subreddit for their suggestions that helped in improving this roadmap.

Contribution

If you think that this roadmap can be improved in anyway or you know about some good learning resources that can be added here, please start an issue or a pull request. I’ll be maintaining and updating this repository frequently.

The source file is created using Microsoft Visio in .vsdx format and included in this repository for your contributions. If you do not have Microsoft Visio or you want to use free software, you can use draw.io which can import and export .vsdx files.