@@ -38,7 +38,7 @@ The [interactive roadmap](https://m3y54m.github.io/Embedded-Engineering-Roadmap/
- **Topics** come from heading depth: `##` is a group, `###` a main topic, `####` and deeper are subtopics. The emojis in headings (✳️ 🔵 🔶 🔸) are decoration only. Renaming a heading changes its link (`#/topic-name`).
- **Resources** are list items in the form `- [📘👶💎 Title](https://url)`, optionally followed by a dash and a short note. Symbols: 📘 book, 🎞️ video, 📝 article, 🔗 link, 🎧 audio, 👶 beginner, 💎 essential. `python3 .github/scripts/check_readme.py` checks the format and duplicates.
- **The map** (`explorer/map.json`) draws only the main topics. Each label on it opens the README heading with the same name. If the wording differs, or the label has no section of its own, add `"Label": ["README heading"]` to `readme` in `explorer/map.json`. A new main topic needs a README section and a box in `explorer/map.json` (and at least one entry in `links`), unless it should stay off the map: then list its title or group in `offMap`. CI warns about main topics that are neither.
- **The map** (`explorer/map.json`) draws only the main topics. Each label on it opens the README heading with the same name. If the wording differs, or the label has no section of its own, add `"Label": ["README heading"]` to `readme` in `explorer/map.json`. A new main topic needs a README section and a box in `explorer/map.json` (and at least one entry in `links`), unless it should stay off the map: then list its title or group in `offMap`. CI warns about main topics that are neither. Each box has a learning priority, `required`, `recommended` or `possible` (shown as Optional); it is a general guide, so rate a topic by what a typical embedded systems engineer needs.
- **Preview and test locally:** `python3 -m http.server 8765` from the repository root, then open `/explorer/`; `node --test explorer/parser.test.mjs` runs the checks CI runs.
[](https://github.com/m3y54m/Embedded-Engineering-Roadmap/releases/latest)
[](https://github.com/m3y54m/Embedded-Engineering-Roadmap/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.
This roadmap is created 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! 😀
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 need to be motivated and passionate about it. As the saying goes, "Hardware is hard!" But don't panic: be patient with the challenges you will meet along this exciting journey. With enough time and effort spent practicing and building projects, you will soon be a real embedded engineer! 😀
## ❓ What is an Embedded System?
### 📖 Embedded System Definitions
Standards, books and glossaries word it differently, but the common idea is a computer built into a larger product to perform a dedicated function, usually with tight limits on cost, size, power and reliability.
> **computer system** that is **part of a larger system** and **performs some of the requirements of that system**. For example, a computer system
@@ -42,24 +46,24 @@ used in an aircraft or rapid transit system.
## 🗺️ The Roadmap
🌐 **[Open the interactive roadmap](https://m3y54m.github.io/Embedded-Engineering-Roadmap/)** to explore it in your browser. Click any topic to read its description and see its learning resources, hover over it to see the topics it is related to, filter topics by area (software, hardware, soft skills) or importance, and search across all topics and resources. The roadmap can also be downloaded there as a PDF or PNG image.
🌐 **[Open the interactive roadmap](https://m3y54m.github.io/Embedded-Engineering-Roadmap/)** to explore it in your browser. Click any topic to read its description and see its learning resources, hover over it to see the topics it is related to, highlight topics by learning priority (required, recommended or optional), and search across all topics and resources. The roadmap can also be downloaded there as a PDF or PNG image.
[](https://m3y54m.github.io/Embedded-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.
Hardware and software overlap heavily in embedded systems, but specific job titles tend to emphasize one over the other. Roles such as "Embedded Software Engineer/Developer," "Firmware Engineer/Developer" and "Embedded Linux Engineer/Developer" focus mainly on software development. Positions such as "Embedded Hardware Engineer" and "Hardware Design Engineer" deal mainly with hardware design and electronics. Roles such as "Embedded Systems Engineer" require a solid understanding of both.
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.
Each company in the embedded industry may have its own requirements for a given job title, so tailor your focus to your career goals. If you're seeking an embedded software position, prioritize the software skills in the roadmap. If you're interested in an embedded hardware job, concentrate on the hardware skills and spend more time 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.
The roadmap covers the essential topics for a typical "Embedded Systems Engineer" role. By studying both software and hardware, you can build the skills to thrive in this dynamic field. If you have a clear preference for one side, you can tailor your learning path accordingly.
🔗 For more information about the history behind this roadmap, read this article: [Embedded Systems Roadmap: Bridging the Gap](https://interrupt.memfault.com/blog/embedded-systems-roadmap-bridging-the-gap)
<!-- markdownlint-disable MD028 -->
> [!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.**
> **Remember that the priority of individual software and hardware skills can differ depending on the company's requirements 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.
@@ -83,11 +87,11 @@ The roadmap provides a comprehensive guide to the essential topics for a typical
## 😕 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.**
**If you feel overwhelmed by the long list of topics in the roadmap, you're not alone. Before delving too deeply, ease into it with some simple starter projects. Learning embedded systems engineering takes time and effort, so don't get discouraged if you don't understand something right away. Keep practicing and you will 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.
Hands-on projects are the most effective way to learn, far better than relying solely on theory from books or articles. Even a seemingly basic project can teach you more than hours of aimless reading. Refer to books, articles and courses when you get stuck on 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.
@@ -112,7 +116,7 @@ Use search engines to find the answers to your questions.
- [🔗 Bing](https://www.bing.com/)
- [🔗 DuckDuckGo](https://duckduckgo.com/)
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 search engines don't help, AI chatbots can also assist. Keep in mind that AI can give incorrect answers, so confirm anything important against more reliable references.
- [🔗 DuckDuckGo AI Chat](https://duck.ai/)
- [🔗 Google Gemini](https://gemini.google.com)
@@ -120,20 +124,20 @@ If you can't find what you're looking for using search engines, AI chatbots can
- [🔗 Microsoft Copilot](https://copilot.microsoft.com)
- [🔗 Claude AI](https://claude.ai/chats)
If you have reservations about relying on AI advice alone, you can also ask your questions from real people:
If you have reservations about relying on AI advice alone, you can also ask real people:
As an embedded systems engineer, it's essential to stay up-to-date with industry trends, best practices, and new technologies to advance your career. Here are some resources to help you achieve your career goals:
To advance your career as an embedded systems engineer, it's essential to stay uptodate with industry trends, best practices and new technologies. These resources can help:
- [🔗 EmbeddedJobs](https://embedded.jobs/jobs) - A job board focused exclusively on Embedded Systems job market.
- [🔗 EmbeddedJobs](https://embedded.jobs/jobs) - A job board focused exclusively on the embedded systems job market.
### 🎥 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.
You may have heard that YouTube is a university, and it's true: there is an extensive amount of invaluable free embedded systems content on YouTube. You'll also find some excellent free courses on Coursera and edX, and Udemy offers some high-quality paid ones.
- [🎞️ Coursera - Introduction to Embedded Systems Software and Development Environments](https://www.coursera.org/learn/introduction-embedded-systems)
@@ -152,9 +156,9 @@ You may have heard that YouTube is a university. And it's true - there is an ext
### 🕹️ Arduino
If you do not have any background in programming 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.
If you have no background in programming embedded systems, Arduino boards and libraries are the best place to start learning the basics. Just keep in mind that most Arduino libraries are written for learning purposes and are not optimized for industrial use.
Additionally, the [Arduino Core](https://github.com/arduino/ArduinoCore-avr) (the platform-specific implementation of the hardware-independent [ArduinoCore-API](https://github.com/arduino/ArduinoCore-API)) 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.
The [Arduino Core](https://github.com/arduino/ArduinoCore-avr) (the platform-specific implementation of the hardware-independent [ArduinoCore-API](https://github.com/arduino/ArduinoCore-API)) also takes care of most of the low-level hardware operations that an embedded engineer should be able to handle, or at least clearly understand. To become a professional embedded developer, learn to use the industry-standard APIs and SDKs provided by microcontroller vendors, such as CMSIS for ARM Cortex-M microcontrollers, STM32Cube for STM32 and ESP-IDF for Espressif microcontrollers.
- [🔗 Getting Started with Arduino](https://docs.arduino.cc/learn/starting-guide/getting-started-arduino)
An IDE or editor ties the compiler, debugger and flashing tools together so that a first program runs on the board quickly. Which one fits depends on your microcontroller family and how much you want to configure yourself.
#### 🔵 Vendor IDEs
Vendor IDEs bundle the toolchain, debugger integration and peripheral configuration tools for their microcontrollers, which makes them a quick way to bring up a first target.
- [🔗 Keil MDK & µVision](https://www.keil.com/)
- [🔗 IAR Embedded Workbench](https://www.iar.com)
@@ -198,32 +208,35 @@ Additionally, the [Arduino Core](https://github.com/arduino/ArduinoCore-avr) (th
- [🔗 MPLAB® X IDE](https://www.microchip.com/en-us/tools-resources/develop/mplab-x-ide)
- [🔗 MCUXpresso for VS Code](https://marketplace.visualstudio.com/items?itemName=NXPSemiconductors.mcuxpresso)
### 🐜 PlatformIO
#### 🔵 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 a professional, cross-platform, cross-architecture and multi-framework development tool for embedded systems engineers and for software developers who write applications for embedded products.
- [🔗 PlatformIO - A professional collaborative platform for embedded development](https://platformio.org/)
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.
PlatformIO is not yet widely adopted in industrial and large-scale projects, but it is an excellent choice for smaller projects. It greatly reduces the effort of installing frameworks and setting up build and debug tools, so you can 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.
> You do not need to read every book and article or watch every video listed here. Trying to do so will only leave you tired and discouraged, because it could take years. Study enough to gain at least a basic understanding of the required topics. Of course, the more time you spend studying and building projects, the deeper 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.
> Some of the resources here are only meant as references. Refer to them 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.
Like other professionals, embedded engineers need soft skills, which can't be learned solely by reading or watching videos. They are developed through interacting with others and overcoming obstacles at work. Improving them is not a one-size-fits-all process: it varies with your individual traits and requires self-awareness of your strengths and areas for growth. It takes time and effort.
- [📝 Soft Skills For Embedded Systems Software Developers](https://www.embeddedrelated.com/showarticle/1470.php)
- [📝 10 Skills Every Embedded Engineer Should Have](https://medium.com/@lanceharvieruntime/10-skills-every-embedded-engineer-should-have-dcb867095b91)
@@ -268,14 +281,20 @@ _________________
### ✳️ Electronics
Electronics knowledge lets firmware engineers read schematics and datasheets, understand voltage levels, current limits and timing, and tell a hardware fault from a software bug.
#### 🔵 Basic Calculus
Calculus underpins signal processing, control theory and the behavior of circuits with capacitors and inductors.
- [🎞️ Khan Academy - Calculus 1](https://www.khanacademy.org/math/calculus-1)
- [📘👶 Calculus For Dummies - Mark Ryan](https://a.co/d/cyvZqE1)
- [📘💎 Thomas' Calculus](https://a.co/d/gFcCC37)
#### 🔵 Principles of Electric Circuits
Ohm's and Kirchhoff's laws, RC and RL circuits and AC basics are what you need to size pull-up resistors, filters and power supplies around a microcontroller.
- [🔗👶 Lessons in Electric Circuits (All About Circuits)](https://www.allaboutcircuits.com/textbook/)
- [📘👶💎 Fundamentals of Electric Circuits - Charles K. Alexander, Matthew Sadiku](https://www.amazon.com/dp/1260226409?ref_=cm_sw_r_cp_ud_dp_Q11YHXNY2BK530RQZC4S)
@@ -284,6 +303,8 @@ _________________
#### 🔵 Electronics Fundamentals
The building blocks that appear around every microcontroller: resistors, capacitors, diodes, transistors and op-amps, and how they behave in real circuits.
- [📘👶 Make: Electronics: Learning by Discovery - Charles Platt](https://a.co/d/fbRoM1R)
@@ -297,6 +318,8 @@ _________________
#### 🔵 Digital Design
Logic gates, flip-flops and registers are the hardware inside microcontrollers and FPGAs; understanding them explains how peripherals, buses and timing work.
- [🔗👶 Tiny Tapeout > Digital Design Guide](https://tinytapeout.com/digital_design/)
- [🔗👶 Mvidia - From Transistors to Teraflops (interactive course)](https://jaso1024.com/mvidia/)
- [📘💎 Digital Design - Morris Mano, Michael Ciletti](https://a.co/d/c3tBaoc)
@@ -306,7 +329,7 @@ _________________
#### 🔵 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.
Computer architecture is the backbone of embedded systems, governing how hardware and software interact. Embedded developers need to understand it to design, develop and debug embedded software effectively. ARM and RISC-V are the two most prevalent instruction set architectures (ISAs) in embedded systems, so expertise in them is valuable: ARM is dominant, while RISC-V is gaining traction thanks to its open-source nature and flexibility.
- [📘👶💎 Computer Organization and Design: ARM Edition - David A. Patterson, John L. Hennessy](https://a.co/d/8YPUXG7)
- [📘👶💎 Digital Design and Computer Architecture: ARM Edition - Sarah Harris, David Harris](https://a.co/d/4otoVvI)
@@ -323,19 +346,25 @@ _________________
### ✳️ 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.
Embedded systems are verified with instruments as well as code. Multimeters, oscilloscopes, logic analyzers, power supplies and function generators let you measure signals, inject stimuli and see what the hardware really does.
#### 🔵 Multimeter
Measures voltage, current, resistance and continuity. It is the first tool for checking power rails, connections and short circuits.
- [🎞️👶 Learn How to Use a Multimeter!](https://youtu.be/4lAyzRxsbDc)
- [📝👶 How to Use a Multimeter](https://learn.sparkfun.com/tutorials/how-to-use-a-multimeter/all)
#### 🔵 Logic / Protocol Analyzer
Captures digital signals and decodes protocols such as UART, I2C, SPI and CAN, so you can see exactly what is exchanged on the wires.
Shows signals over time: edges, rise times, noise, glitches and power supply ripple that a logic analyzer cannot show.
- [🎞️👶 What’s an OSCILLOSCOPE?](https://youtu.be/DgYGRtkd9Vs)
- [🎞️👶 How to Use an Oscilloscope](https://youtu.be/u4zyptPLlJI)
- [🎞️👶 How to use an oscilloscope / What is an oscilloscope / Oscilloscope tutorial](https://youtu.be/CzY2abWCVTY)
@@ -345,23 +374,27 @@ _________________
### ✳️ 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.
Hardware design and prototyping are primarily the responsibility of electronic hardware design engineers, but embedded software engineers benefit from understanding them too. This knowledge helps identify and resolve hardware-related issues while debugging an embedded system. With a grasp of hardware principles, software engineers can pinpoint the root causes of problems and troubleshoot faster.
#### 🔵 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.
Breadboarding is a hands-on approach to prototyping circuits, providing a versatile platform for experimentation and design. Breadboards are easy to use, flexible and inexpensive, and they let developers connect components, then test and refine a design without permanent soldering. This allows rapid iteration and efficient debugging, which makes breadboarding an invaluable tool for embedded system development.
- [🎞️👶 Everything You Need to Know about Breadboards](https://www.youtube.com/watch?v=mE33WpRWrXs)
- [🎞️👶 How to Use a Breadboard](https://youtu.be/6WReFkfrUIk)
#### 🔵 Hardware Design Basics
Reading schematics, choosing components, and designing the power supply, reset and clock circuits that a microcontroller needs to run.
- [🎞️ Microcontroller-Based Hardware Design With Altium Designer (YouTube Playlist)](https://www.youtube.com/playlist?list=PL3aaAq2OJU5HcbClqrOhqBDozF7HmxV-s)
#### 🔵 PCB Design / EMC
Turning a schematic into a board. Layout, grounding and decoupling decide signal integrity and electromagnetic compatibility (EMC), and whether a product passes certification.
- [🎞️💎 Altium Academy YouTube Channel](https://www.youtube.com/@AltiumAcademy)
- [🎞️💎 Robert Feranec YouTube Channel](https://www.youtube.com/@RobertFeranec)
- [🎞️👶 Altium Tutorials for Beginners - Robert Feranec (YouTube Playlist)](https://www.youtube.com/playlist?list=PLXvLToQzgzdduBaD4horowdWgcG5uGUW4)
@@ -387,6 +420,8 @@ Breadboarding is a hands-on approach to prototyping circuits, providing a versat
#### 🔵 Soldering / Rework
Assembling prototypes and repairing boards, from through-hole parts to fine-pitch SMD components, including replacing parts with hot air.
- [🎞️👶 How To Solder - Electronics with Becky Stern | Digi-Key Electronics](https://www.youtube.com/watch?v=sS4v2hIFp9I)
- [🎞️👶 HOW TO SOLDER! (Beginner's Guide)](https://www.youtube.com/watch?v=3jAw41LRBxU)
- [🎞️👶 Soldering Crash Course: Basic Techniques, Tips and Advice!](https://www.youtube.com/watch?v=6rmErwU5E-k)
@@ -398,7 +433,7 @@ _________________
### ✳️ 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.
FPGAs (Field-Programmable Gate Arrays) are integrated circuits that can be configured to implement digital logic. They are widely used in embedded systems for their high performance, flexibility and cost-effectiveness. FPGA designers use hardware description languages (HDLs) to create custom circuits that map directly onto the FPGA architecture. Because FPGA design and verification differ significantly from embedded software development, it is a specialized domain within embedded systems.
- [📝 What are FPGAs?](https://hackaday.io/project/27550-the-hobbyists-guide-to-fpgas/log/68114-what-are-fpgas)
@@ -412,7 +447,7 @@ _________________
### ✳️ 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.
Mastering programming fundamentals and software development principles is essential for successful embedded design. Resource-constrained environments demand efficient code, optimized data management, reusable design patterns and effective memory management. Embedded developers need a strong foundation in these core concepts to build reliable, performant systems.
#### 🔵 Discrete Mathematics
@@ -430,6 +465,8 @@ Discrete mathematics is the theoretical basis of computer science and engineerin
#### 🔵 Algorithms & Data Structures
Tight RAM and CPU budgets shape the choices: fixed-size buffers, ring buffers, queues and lookup tables are more common in firmware than dynamic structures.
- [📘👶💎 Grokking Algorithms - Aditya Y. Bhargava](https://www.manning.com/books/grokking-algorithms)
- [📘💎 Introduction to Algorithms - Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein](http://mitpress.mit.edu/9780262367509/introduction-to-algorithms/)
- [🔗 Collection of various algorithms in mathematics, machine learning, computer science, physics, etc implemented in C for educational purposes](https://github.com/TheAlgorithms/C)
@@ -440,6 +477,8 @@ Discrete mathematics is the theoretical basis of computer science and engineerin
#### 🔵 Design Patterns
Patterns that work without heavy object orientation or dynamic allocation, such as state, observer, opaque pointers and layered hardware abstractions.
- [📝 Practical Design Patterns: Opaque Pointers and Objects in C](https://interrupt.memfault.com/blog/opaque-pointers)
- [📘💎 Design Patterns for Embedded Systems in C - Bruce Powel Douglass](https://www.oreilly.com/library/view/design-patterns-for/9781856177078/)
- [📘💎 Making Embedded Systems: Design Patterns for Great Software - Elecia White](https://www.oreilly.com/library/view/making-embedded-systems/9781449308889/)
@@ -448,6 +487,8 @@ Discrete mathematics is the theoretical basis of computer science and engineerin
#### 🔵 State Machines
Most embedded behavior, such as protocols, user interfaces and device modes, is a state machine reacting to events. Making states explicit keeps it predictable and testable.
- [📝 Programming embedded systems the easy way – with state machines](https://www.embedded.com/programming-embedded-systems-the-easy-way-with-state-machines/)
- [🎞️💎 State Machines (YouTube Playlist)](https://www.youtube.com/playlist?list=PLPW8O6W-1chxym7TgIPV9k5E8YJtSBToI)
@@ -458,6 +499,8 @@ Discrete mathematics is the theoretical basis of computer science and engineerin
#### 🔵 Memory Management
Firmware usually avoids malloc after startup and relies on static allocation, stacks of known size and memory pools. Understanding the stack, the heap and the linker's memory map helps prevent overflows and fragmentation.
- [🎞️ Understanding the C runtime memory model](https://www.youtube.com/watch?v=3F3lp_F2YpQ)
- [🎞️ Pointers and dynamic memory - stack vs heap](https://www.youtube.com/watch?v=_8-ht2AKyH4)
- [🎞️ Dynamic Memory Allocation | C Programming Tutorial](https://www.youtube.com/watch?v=R0qIYWo8igs)
@@ -470,10 +513,12 @@ _________________
### ✳️ 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.
Low-level languages like C and assembly provide direct hardware access, enabling efficient 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 used to test embedded systems because of its simplicity.
#### 🔵 C
The dominant language of embedded firmware: close to the hardware, with a minimal runtime, predictable memory use and support in every toolchain.
- [🎞️👶 Microchip University - Syntax And Structure of C - Simply C](https://mu.microchip.com/syntax-and-structure-of-c)
- [🎞️💎 Microchip University - Advanced C Programming](https://mu.microchip.com/advanced-c-programming)
- [🎞️💎 Microchip University - Advanced Embedded C Tips, Tricks, and Cautions](https://mu.microchip.com/advanced-embedded-c-tips-tricks-and-cautions)
@@ -499,6 +544,8 @@ Low-level languages like C and assembly provide direct hardware access, enabling
#### 🔵 C++
Adds classes, templates and stronger type checking on top of C at little or no runtime cost, when used without exceptions, RTTI and heavy dynamic allocation.
- [📝 Modern C++ in Embedded Development: (Don't Fear) The ++](https://www.embeddedrelated.com/showarticle/1532.php)
- [📝 C++ On Embedded Systems](https://blog.mbedded.ninja/programming/languages/c-plus-plus/cpp-on-embedded-systems/)
- [📝💎 Bare Metal C++ - Alexey Rybachuk](https://arobenko.github.io/bare_metal_cpp/)
@@ -520,6 +567,8 @@ Low-level languages like C and assembly provide direct hardware access, enabling
#### 🔵 Assembly
Needed for startup code, interrupt entry and the rare hot spot, and for reading disassembly while debugging. ARM and RISC-V are the most common instruction sets.
- [📝👶 Introduction to ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)
- [🎞️ Udemy – ARM GNU Assembly Programming From Ground Up](https://www.udemy.com/course/arm-gnu-assembly-programming-from-ground-uptm/)
- [🎞️ Assembly Language Programming with ARM – Full Tutorial for Beginners](https://www.youtube.com/watch?v=gfmRrPjnEw4)
@@ -529,6 +578,8 @@ Low-level languages like C and assembly provide direct hardware access, enabling
#### 🔵 Python
Used on the host for test automation, tooling and scripting, and on microcontrollers through MicroPython and CircuitPython.
- [📝 Python for embedded systems testing](https://www.elsys-design.com/en/python-embedded-systems-testing/)
- [📝👶 The Python Handbook – Learn Python for Beginners](https://www.freecodecamp.org/news/the-python-handbook/)
- [🔗💎 Real Python: Python Tutorials](https://realpython.com/)
@@ -544,6 +595,8 @@ Low-level languages like C and assembly provide direct hardware access, enabling
#### 🔵 Rust
A memory-safe systems language without a garbage collector. It is gaining ground in embedded for firmware that must be both safe and efficient.
- [📝 5 roadblocks to Rust adoption in embedded systems](https://www.embedded.com/5-roadblocks-to-rust-adoption-in-embedded-systems/)
- [🔗 The Embedded Rust Book](https://docs.rust-embedded.org/book/)
- [🎞️ The Future of Programming: Rust (YouTube Playlist)](https://www.youtube.com/playlist?list=PLc7W4b0WHTAUAEAguiqpNa5H0QqXJIJI6)
@@ -568,9 +621,9 @@ _________________
### ✳️ 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.
Microcontrollers are integrated circuits (ICs) that combine a processor core, memory and input/output (I/O) peripherals on a single chip. Designed for embedded applications, they control devices in many 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.
Popular microcontroller families include STM32, ESP32, nRF, RP2040/RP2350, and the NXP and Renesas lines, alongside long-established AVR, PIC and MSP430. Choosing the right one involves assessing application requirements, processing power, memory needs and input/output capabilities, and considering ease of use, cost, reliability, availability and future expansion.
- [📝 What Is a Microcontroller? The Defining Characteristics and Architecture of a Common Component](https://www.allaboutcircuits.com/technical-articles/what-is-a-microcontroller-introduction-component-characteristics-component/)
- [📝 How to Choose the Right Microcontroller for Your Application](https://www.allaboutcircuits.com/technical-articles/how-to-choose-the-right-microcontroller-for-your-application/)
@@ -596,37 +649,51 @@ Some popular microcontroller families include AVR, PIC, STM32, MSP430, nRF, and
#### 🔵 GPIO
Pins that firmware configures as digital inputs or outputs, with pull-ups, open-drain or alternate functions. The basis for LEDs, buttons and bit-banged protocols.
- [🎞️ Tutorial 5: Peripheral 1 - General purpose Input Output (GPIO) Configuration in STM32](https://youtu.be/tjDhmavBGf0)
#### 🔵 ADC
Converts an analog voltage into a digital value. Resolution, sampling rate, reference voltage and noise determine how accurate readings are.
- [🎞️ How Do ADCs Work? - The Learning Circuit](https://www.youtube.com/watch?v=g4BvbAKNQ90)
- [🎞️ Tutorial 13: ADC in STM32F4](https://youtu.be/vIlG_i3GqeU)
- [🎞️ Tutorial 14: ADC by Polling](https://www.youtube.com/watch?v=uUi6JyUuEJA)
#### 🔵 DAC
Converts a digital value into an analog voltage, used for audio, waveform generation and set-points.
- [🎞️ How Do DACs Work? - The Learning Circuit](https://www.youtube.com/watch?v=YAxrmoVtEtE)
- [🎞️ DAC in STM32 || Sine wave || HAL || CubeIDE](https://www.youtube.com/watch?v=6Z1L6ox63j0)
#### 🔵 Timers / Counters
Count clock cycles to measure time, generate periodic interrupts and capture or generate signals. They are the base of scheduling and PWM.
- [📝 Introduction to Microcontroller Timers: Periodic Timers](https://www.allaboutcircuits.com/technical-articles/introduction-to-microcontroller-timers-periodic-timers/)
- [📝 Timers and Counters (AVR) - Nick Gammon](https://www.gammon.com.au/timers)
A low-power clock that keeps calendar time, often from a backup battery, and can wake the microcontroller from sleep.
- [📝 Real Time Clocks (RTCs) in Microcontroller Timers](https://www.allaboutcircuits.com/technical-articles/introduction-to-microcontroller-timers-real-time-clocks/)
#### 🔵 Watchdog
A timer that resets the microcontroller if the firmware stops servicing it, so the device recovers from hangs on its own.
- [📝 A Guide to Watchdog Timers for Embedded Systems](https://interrupt.memfault.com/blog/firmware-watchdog-best-practices)
- [📝 Watchdog Timers in Microcontrollers](https://www.allaboutcircuits.com/technical-articles/watchdog-timers-microcontroller-timers/)
- [🎞️ The Watchdog Timer on Arduino](https://www.youtube.com/watch?v=AzZBgH67mgE)
@@ -634,6 +701,8 @@ Some popular microcontroller families include AVR, PIC, STM32, MSP430, nRF, and
#### 🔵 Interrupts
Let hardware events preempt the running code immediately. Priorities, latency and short handlers are central to responsive firmware.
@@ -650,6 +721,8 @@ Some popular microcontroller families include AVR, PIC, STM32, MSP430, nRF, and
#### 🔵 Clock Management
Clock sources, PLLs and dividers set CPU and peripheral speed and affect accuracy and power. A misconfigured clock is a common source of mysterious problems.
- [📝 Clock Configuration in STM32](https://medium.com/@csrohit/clock-configuration-in-stm32-6a058da220e0)
- [🎞️ STM32: Change clock speed via registers](https://www.youtube.com/watch?v=W_9jPMgiqaQ)
- [🎞️ #1. Intro to STM32F4 Register Based Programming || Clock Setup || LED Blinking || NO HAL](https://www.youtube.com/watch?v=GJ_LFAlOlSk)
@@ -658,11 +731,15 @@ Some popular microcontroller families include AVR, PIC, STM32, MSP430, nRF, and
#### 🔵 Power Management
Sleep and low-power modes, wake-up sources and clock gating are what let battery-powered devices last for months or years.
- [🎞️ SLEEP Mode in STM32F103 || CubeIDE || Low Power Mode || Current Consumption](https://www.youtube.com/watch?v=2rKcsGkCG0s)
- [🎞️ STOP MODE in STM32 || CubeIDE || Low Power Mode](https://www.youtube.com/watch?v=UtQhc4XV8k4)
#### 🔵 Bootloader / DFU (Device Firmware Update)
A small program that starts first, checks the application image and can update the firmware over UART, USB or the air.
- [📝 Basics to Developing Bootloader for Arduino](https://www.electronicwings.com/arduino/basics-to-developing-bootloader-for-arduino)
- [📝 From Zero to main(): How to Write a Bootloader from Scratch](https://interrupt.memfault.com/blog/how-to-write-a-bootloader-from-scratch)
- [🎞️ How to Create a Super Simple Bootloader](https://www.youtube.com/watch?v=OkUQ3iMmiYQ&list=PLnMKNibPkDnEb1sphpdFJ3bR9dNy7S6mO)
@@ -675,10 +752,12 @@ _________________
### ✳️ 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.
Embedded systems exchange data with sensors, memories, displays, other chips and the outside world. An interface is the physical connection and a protocol defines how data is exchanged over it. The right choice depends on bandwidth, distance, number of wires, power consumption, cost and available hardware support.
#### 🔵 Basic Protocols
Short-distance serial buses such as UART, I2C and SPI that connect a microcontroller to sensors, memories, displays and other chips on the same board.
- [🎞️👶 Understanding Serial Protocols](https://www.youtube.com/watch?v=LEz5UCN3aHA)
- [🎞️👶 Serial Protocol Fundamentals](https://www.youtube.com/watch?v=yz7h5xd18OE)
- [📝👶 Understanding and Selecting in 2024: I2C, SPI, UART Explained](https://www.parlezvoustech.com/en/comparaison-protocoles-communication-i2c-spi-uart/)
@@ -724,6 +803,8 @@ Embedded systems often communicate with other devices or external systems via in
#### 🔵 Digital Audio Protocols
Interfaces that move audio samples between a microcontroller or processor and codecs, microphones and amplifiers.
##### 🔶 I2S
- [📝 Introduction to the I2S Interface](https://www.allaboutcircuits.com/technical-articles/introduction-to-the-i2s-interface/)
@@ -737,6 +818,8 @@ Embedded systems often communicate with other devices or external systems via in
#### 🔵 Display & Camera Protocols
Interfaces for displays and image sensors, from simple control buses to the high-speed MIPI links used with application processors.
@@ -760,6 +843,8 @@ Embedded systems often communicate with other devices or external systems via in
#### 🔵 Wireless Protocols
Radio links trade off range, data rate, power consumption and ecosystem: low-power short range (BLE, Zigbee, Thread), long range (LoRa), high throughput (Wi-Fi) and ranging (UWB).
##### 🔶 Bluetooth / BLE
- [🎞️👶💎 Microchip University - First Steps into Bluetooth Low Energy (BLE)](https://mu.microchip.com/first-steps-into-bluetooth-low-energy-ble)
@@ -809,6 +894,8 @@ Embedded systems often communicate with other devices or external systems via in
#### 🔵 Industrial Protocols
Fieldbus and industrial Ethernet protocols that connect controllers, sensors and drives in factories and automation systems.
##### 🔶 Modbus
- [🎞️ What is Modbus and How does it Work?](https://www.youtube.com/watch?v=txi2p5_OjKU)
@@ -838,6 +925,8 @@ Embedded systems often communicate with other devices or external systems via in
#### 🔵 High-Speed Protocols
Wired links for high data rates, such as Ethernet, USB and PCIe. They usually need a hardware controller, a protocol stack and careful PCB layout.
##### 🔶 Ethernet
- [🎞️👶 Microchip University - Ethernet Fundamentals](https://mu.microchip.com/ethernet-fundamentals)
@@ -868,6 +957,8 @@ Embedded systems often communicate with other devices or external systems via in
#### 🔵 Automotive Protocols
Vehicle networks that connect electronic control units (ECUs), from the low-cost LIN to CAN, FlexRay and MOST. They are built for robust, real-time communication in electrically noisy environments.
##### 🔶 CAN
- [🎞️👶 Microchip University - CAN and CAN FD Protocol and Physical Layer Basics](https://mu.microchip.com/understanding-the-can-fd-protocol)
@@ -898,6 +989,8 @@ Embedded systems often communicate with other devices or external systems via in
#### 🔵 Network Protocols / Socket Programming
How devices communicate over IP networks: TCP and UDP sockets, and the lightweight IP stacks such as lwIP that run on microcontrollers and embedded Linux.
- [🎞️ TCP vs UDP - Explaining Facts and Debunking Myths - TCP Masterclass](https://www.youtube.com/watch?v=jE_FcgpQ7Co)
- [🎞️ TCP - 12 simple ideas to explain the Transmission Control Protocol](https://www.youtube.com/watch?v=JFch3ctY6nE)
@@ -913,6 +1006,8 @@ Embedded systems often communicate with other devices or external systems via in
#### 🔵 Cellular Communication
Cellular modems give a device wide-area connectivity: 4G modems for high throughput, and low-power IoT variants (LTE-M, NB-IoT) designed for battery-powered devices.
##### 🔶 GSM / LTE
- [🎞️ STM32 : Internet Of Things With 4G LTE Modem (YouTube Playlist)](https://www.youtube.com/playlist?list=PL2_RO8p04imYY5JOrCDT7V0hnzkgyExRe)
@@ -925,12 +1020,14 @@ _________________
### ✳️ 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.
Embedded systems combine volatile (SRAM, DRAM, PSRAM) and non-volatile (flash, EEPROM, FRAM) memory to store and access data, chosen by factors such as performance, cost, power consumption and durability.
- [📝 Memory Options for Embedded Systems: How to Select the Right Memory Configuration](https://www.qt.io/software-insights/how-to-select-a-memory-configuration-for-embedded-systems)
#### 🔵 Flash Memory
Non-volatile memory that stores firmware and data. It is erased in blocks and wears out with writes; NOR flash suits code execution, NAND flash suits bulk storage.
- [📝 NAND and eMMC: All You Need to Know About Flash Memory](https://www.makeuseof.com/tag/nand-emmc-need-know-flash-memory/)
##### 🔶 NOR / NAND
@@ -949,10 +1046,14 @@ Embedded systems employ a combination of volatile (SRAM, DRAM, PSRAM) and non-vo
#### 🔵 EEPROM
Byte-erasable non-volatile memory for small amounts of data such as settings and calibration values, with a limited number of write cycles.
- [🎞️ Using EEPROM with Arduino - Internal & External](https://www.youtube.com/watch?v=ShqvATqXA7g)
#### 🔵 SRAM / DRAM
Fast volatile memory. SRAM is built into the microcontroller and needs no refresh; DRAM is larger and cheaper but needs a memory controller and periodic refresh.
- [📝 SRAM vs DRAM: Difference Between SRAM & DRAM Explained](https://www.enterprisestorageforum.com/hardware/sram-vs-dram/)
- [🎞️ What is SRAM?](https://www.youtube.com/watch?v=kU2SsUUsftA)
@@ -960,7 +1061,7 @@ Embedded systems employ a combination of volatile (SRAM, DRAM, PSRAM) and non-vo
#### 🔵 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.
A file system organizes data on a storage device. Embedded devices need ones designed for the medium: flash wears out and is erased in blocks, so wear leveling and power-loss safety matter more than speed (for example LittleFS, FAT on SD cards, or UBIFS and ext4 on eMMC under Linux). Small microcontrollers often need no file system at all.
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.
Embedded development often involves simulating or emulating hardware to test and debug software before deploying it on actual hardware. Simulators create virtual models of hardware systems, while emulators reproduce the behavior of the real hardware closely enough to run the actual firmware. These tools reduce development time and hardware costs and improve software reliability.
@@ -989,6 +1090,8 @@ Embedded system development often involves simulating or emulating hardware envi
#### 🔵 QEMU
A general machine emulator that can boot kernels and firmware for many architectures and boards without hardware, widely used for embedded Linux and RTOS development.
- [📝 Running AVR code in QEMU - A quick-start guide to accelerate AVR firmware development](https://yeah.nah.nz/embedded/qemu-avr/)
- [📝 QEMU Simulation - Blinky - STM32F767ZI Full Stack](https://longer-vision-robot.gitbook.io/stm32f767zi-full-stack/chapter-2.-programming-for-stm32/2.4-qemu-simulation-blinky)
@@ -997,6 +1100,8 @@ Embedded system development often involves simulating or emulating hardware envi
#### 🔵 Renode
An open-source framework that simulates whole embedded systems, including peripherals and multiple nodes, which makes firmware testable in CI without boards.
- [🔗 Renode - Running your first demo](https://renode.readthedocs.io/en/latest/introduction/demo.html)
@@ -1008,7 +1113,7 @@ _________________
### ✳️ 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 and actuators are the eyes and hands of embedded systems: they gather information about the environment and act on it. Sensors convert physical phenomena, such as temperature, light or sound, into electrical signals that the embedded system can process. Actuators do the opposite, converting electrical signals into physical actions, such as controlling the speed of a motor or opening and closing a valve.
- [🎞️💎 Coursera - Embedding Sensors and Motors Specialization](https://www.coursera.org/specializations/embedding-sensors-motors)
@@ -1037,10 +1142,12 @@ _________________
### ✳️ 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).
Digital signal processing manipulates sampled signals such as audio, sensor data and radio signals. On microcontrollers it appears as digital filters, FFTs and sensor fusion, running on CPUs with DSP instructions (for example Cortex-M4 and M7), dedicated DSP cores or FPGAs, often in fixed-point arithmetic to save time and energy.
#### 🔵 DSP Basics & Filter Design
Sampling theory, FIR and IIR filters and fixed-point arithmetic: the tools for cleaning up sensor and audio signals in firmware.
- [📘💎 The Scientist and Engineer's Guide to Digital Signal Processing - Steven W. Smith](https://www.dspguide.com/pdfbook.htm)
- [🎞️ FIR Filter Design and Software Implementation - Phil's Lab #17](https://www.youtube.com/watch?v=uNNNj9AZisM)
- [🎞️ IIR Filters - Theory and Implementation (STM32) - Phil's Lab #32](https://www.youtube.com/watch?v=QRMe02kzVkA)
@@ -1054,6 +1161,8 @@ Digital signal processing (DSP) is a branch of engineering that deals with the p
#### 🔵 Discrete Fourier Transform / FFT
Turns time-domain samples into frequencies, used for vibration analysis, audio and sensor data, typically through optimized libraries such as CMSIS-DSP.
- [🎞️ Discrete Fourier Transform - Simple Step by Step](https://www.youtube.com/watch?v=mkGsMWi_j4Q)
- [🎞️ The Fast Fourier Transform (FFT): Most Ingenious Algorithm Ever?](https://youtu.be/h7apO7q16V0)
- [🎞️ The FFT Algorithm - Simple Step by Step](https://www.youtube.com/watch?v=htCj9exbGo0)
@@ -1063,6 +1172,8 @@ _________________
### ✳️ Control Theory
Control theory covers how a system holds a target despite disturbances, such as motor speed, temperature or a drone's attitude. In firmware it appears as control loops running at a fixed sampling rate with sensor feedback and filtering.
- [🎞️ Understanding Control Systems (YouTube Playlist)](https://youtube.com/playlist?list=PLn8PRpmsu08q8CE0pbZ-cSrMm_WYJfVGd)
- [🎞️ Control Systems - CircuitBread (YouTube Playlist)](https://www.youtube.com/playlist?list=PLfYdTiQCV_p4YZNJWExM-5_g0fk9bHDL8)
- [🎞️💎 Brian Douglas' Control Systems Lectures (YouTube Channel)](https://www.youtube.com/@BrianBDouglas)
@@ -1072,6 +1183,8 @@ _________________
#### 🔵 PID Controller
The most widely used controller. It combines proportional, integral and derivative action on the error, and is discretized and tuned in firmware for motors, heaters and many other loops.
- [🎞️👶 What is a PID Controller? | DigiKey](https://www.youtube.com/watch?v=tFVAaUcOm4I)
- [🎞️👶 How to Tune a PID Controller for an Inverted Pendulum | DigiKey](https://www.youtube.com/watch?v=hRnofMxEf3Q)
Model-based design: simulate controllers and algorithms first, then generate C code for the target microcontroller.
- [🎞️ MATLAB Tutorials: Getting Started with MATLAB (YouTube Playlist)](https://youtube.com/playlist?list=PL7CAABC40B2825C8B)
- [🎞️ Getting Started with Simulink (YouTube Playlist)](https://youtube.com/playlist?list=PL484BA2AD3AE4C2D0)
- [🎞️ Udemy – MATLAB/SIMULINK Bible|Go From Zero to Hero!](https://www.udemy.com/course/matlabsimulink-biblego-from-zero-to-hero/)
@@ -1088,10 +1203,12 @@ _________________
### ✳️ 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.
Embedded systems can be programmed either on top of an operating system (OS) or directly on the hardware, which is known as bare-metal programming. Each approach has its own advantages and disadvantages. An embedded OS provides a layer of abstraction between the hardware and the application code and offers resource management, task scheduling, error handling and communication capabilities. However, it adds overhead and may not suit memory-constrained applications.
#### 🔵 Operating System Fundamentals
Processes, scheduling, memory management and drivers: the concepts behind what an RTOS or Linux does for your application.
- [📝👶 Putting the “You” in CPU](https://cpu.land/)
- [📝👶 Operating System in 1,000 Lines](https://operating-system-in-1000-lines.vercel.app/en/)
- [📘👶 The little book about OS development](https://littleosbook.github.io/)
@@ -1105,7 +1222,7 @@ Embedded systems can be programmed with either an operating system (OS) or direc
#### 🔵 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.
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. An RTOS provides a deterministic environment in which tasks run with predictable timing, so critical tasks always execute on time, even in the presence of interrupts and other disruptions.
##### 🔶 RTOS Basics
@@ -1185,7 +1302,7 @@ Real-time operating systems (RTOS) are specialized operating systems designed to
#### 🔵 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.
Embedded Linux runs on application processors rather than small microcontrollers. It is chosen for its networking, file system, USB and graphics stacks and its large software ecosystem, at the cost of more memory, longer boot times and no hard real-time guarantees unless the PREEMPT_RT patch is used.
- [📝 What Is Embedded Linux?](https://www.windriver.com/solutions/learning/embedded-linux)
- [📝 FreeRTOS vs Linux for Embedded Systems](https://www.bytesnap.com/news-blog/freertos-vs-linux-embedded-systems/)
@@ -1250,6 +1367,8 @@ Embedded Android builds on Embedded Linux: the device runs a Linux kernel with A
#### 🔵 Multithreading & Parallel Processing
Running several tasks concurrently on one or more cores brings shared-data hazards such as race conditions, priority inversion and deadlocks. Mutexes, queues and careful design keep them under control.
- [📝 Threading/Concurrency vs Parallelism](http://www.danielmoth.com/Blog/threadingconcurrency-vs-parallelism.aspx)
- [📝 Multi-threading and Parallel Programming](https://dev.to/kwereutosu/multi-threading-and-parallel-programming-1l9m)
- [📝 Multitasking vs Multithreading vs Multiprocessing](https://medium.com/codex/multitasking-vs-multithreading-vs-multiprocessing-2b0087c861ae)
@@ -1267,6 +1386,8 @@ Embedded Android builds on Embedded Linux: the device runs a Linux kernel with A
#### 🔵 Inter-Process Communication (IPC)
How tasks and processes exchange data and signals: queues, shared memory, sockets, pipes and message buses such as D-Bus.
- [📝 Inter Process Communication (IPC)](https://www.scaler.com/topics/operating-system/inter-process-communication-in-os/)
- [📝 What Is Inter-Process Communication In Linux?](https://www.scaler.com/topics/ipc-in-linux/)
- [🎞️ Udemy – Linux Inter Process Communication (IPC) from Scratch in C](https://www.udemy.com/course/linuxipc/)
@@ -1276,19 +1397,21 @@ Embedded Android builds on Embedded Linux: the device runs a Linux kernel with A
#### 🔵 Qt Framework
A C++ framework for GUIs and applications on embedded Linux, with QML for declarative interfaces and a lighter Qt for MCUs edition for microcontrollers.
- [🔗 Qt Documentation](https://doc.qt.io/)
_________________
### ✳️ 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.
Embedded bugs often involve hardware, timing and software together. Debugging combines in-circuit debuggers, logging, tracing, static analysis, simulation and instruments such as oscilloscopes to find the root cause.
- [📝 Using Asserts in Embedded Systems](https://interrupt.memfault.com/blog/asserts-in-embedded-systems)
#### 🔵 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.
JTAG and SWD (Serial Wire Debug) are two popular interface protocols for debugging and programming embedded systems. JTAG is a general-purpose protocol that can debug and program a wide range of devices, while SWD is a simpler, more compact protocol designed specifically for ARM microcontrollers.
- [📝 A Deep Dive into ARM Cortex-M Debug Interfaces](https://interrupt.memfault.com/blog/a-deep-dive-into-arm-cortex-m-debug-interfaces)
- [🔗 Guide: Connecting your debugger](https://stm32-base.org/guides/connecting-your-debugger.html)
@@ -1299,7 +1422,7 @@ JTAG and SWD (Serial Wire Debug) are two popular interface protocols used for de
#### 🔵 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.
GDB is the standard open-source debugger for C, C++ and Rust firmware. Connected through a debug probe and a GDB server such as OpenOCD, it lets you set breakpoints, step through code, and inspect registers, memory and the call stack on the target.
- [📝 How do breakpoints even work?](https://interrupt.memfault.com/blog/cortex-m-breakpoints)
@@ -1311,7 +1434,7 @@ GDB (GNU Debugger) is a powerful and versatile debugger for source-level and mac
#### 🔵 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.
OpenOCD is the open-source bridge between a debug probe (ST-Link, J-Link, CMSIS-DAP and others) and GDB. It talks JTAG or SWD to the target and supports flashing, debugging and boundary scan on a wide range of microcontrollers.
- [🎞️ This Is 100% How You Should Be Debugging | How to Use OpenOCD to Debug Embedded Software with GDB](https://www.youtube.com/watch?v=_1u7IOnivnM)
@@ -1320,11 +1443,11 @@ _________________
### ✳️ 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.
Firmware is cross-compiled for a target that differs from the development machine, linked with a memory layout script and converted to a flashable image. Build systems automate these steps so builds are repeatable on every machine and in CI.
#### 🔵 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.
A cross-compiler such as GCC (arm-none-eabi-gcc, riscv-gcc) or Clang turns C and C++ into code for a specific microcontroller. Its flags, optimization levels, linker scripts and startup code determine size, speed and behavior. Commercial compilers such as Keil and IAR offer vendor-tuned optimization and support that some projects prefer.
- [📝 GCC and Make - Compiling, Linking and Building C/C++ Applications](https://www3.ntu.edu.sg/home/ehchua/programming/cpp/gcc_make.html)
- [📝 The Best and Worst GCC Compiler Flags For Embedded](https://interrupt.memfault.com/blog/best-and-worst-gcc-clang-compiler-flags)
@@ -1335,7 +1458,7 @@ GCC (the GNU Compiler Collection) is a free and open-source compiler system that
#### 🔵 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.
Make rebuilds only what changed, based on rules in a Makefile. CMake generates Makefiles or Ninja files and supports toolchain files for cross-compiling, which is why many embedded SDKs such as Zephyr, the Pico SDK and ESP-IDF use it.
- [📝 A Shallow Dive into GNU Make](https://interrupt.memfault.com/blog/gnu-make-guidelines)
- [🎞️ Building STM32 projects from scratch with cross platform tools like Make, CMake and arm-gcc compiler toolchain (YouTube Playlist)](https://www.youtube.com/playlist?list=PLEg2mgYz66IOcHRvvUDf9O1ZCGy58M1Bt)
@@ -1346,14 +1469,14 @@ CMake and Make are both tools for building software applications. CMake is a met
#### 🔵 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).
Shell scripts glue the toolchain together on Linux and in CI: running builds and tests, flashing boards, parsing serial logs and preparing release images. On Windows, Bash is available through WSL.
- [🎞️ Bash Scripting Tutorial for Beginners](https://www.youtube.com/watch?v=tK9Oc6AEnR4)
#### 🔵 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.
A container image pins the exact compiler, SDK and tool versions, so every developer and CI job builds the same firmware, even years later, and new team members skip a long toolchain setup.
### ✳️ 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.
Embedded projects combine software, hardware and often safety or regulatory requirements, which shapes how development is planned. SDLC models describe how requirements, design, implementation, verification and maintenance are organized, from sequential models such as the V-model to iterative ones such as Agile.
- [📝 What is the software development life cycle?](https://www.coderus.com/the-software-development-lifecycle/)
- [📝 Embedded Product Development Life Cycle: Four Main Steps](https://www.sam-solutions.com/blog/embedded-product-development-life-cycle/)
#### 🔵 Agile / SCRUM
Iterative development in short sprints. In embedded projects it has to account for hardware availability, long lead times and certification.
- [📝 Does agile work with embedded software?](https://www.embedded.com/does-agile-work-with-embedded-software/)
- [📝 What Is Scrum: A Guide to the Most Popular Agile Framework](https://www.scrumalliance.org/about-scrum)
- [🔗 The Scrum Guide](https://scrumguides.org/scrum-guide.html)
@@ -1383,6 +1508,8 @@ Software Development Life Cycle (SDLC) models provide a structured approach to s
#### 🔵 V-Model (V-cycle)
Pairs every development stage with a matching test stage. It is common in safety-critical domains such as automotive, medical and aerospace.
- [📝 What is the V model for software development](https://x-engineer.org/v-model-software-development/)
- [📝 V Model In Software Engineering: Ultimate Guideline](https://biplus.com.vn/v-model-in-software-engineering/)
@@ -1390,10 +1517,12 @@ _________________
### ✳️ 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.
Firmware has to be traceable: every released binary should map to an exact source revision, often together with the hardware design files. Version control tracks changes, supports branches for features and hotfixes, and helps find the change that introduced a bug. Git is the standard; Subversion is still found in older projects.
#### 🔵 Git
The standard distributed version control system. Branches, tags for releases and bisect for finding regressions are used daily in firmware projects.
- [🎞️👶 Git Tutorial for Beginners: Learn Git in 1 Hour](https://www.youtube.com/watch?v=8JJ101D3knE)
- [🎞️ Git for Professionals Tutorial - Tools & Concepts for Mastering Version Control with Git](https://www.youtube.com/watch?v=Uszj_k0DGsg)
@@ -1405,7 +1534,7 @@ _________________
### ✳️ 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.
Embedded testing covers logic that can run on a PC as well as behavior that only appears on real hardware, such as timing, interrupts, peripherals and power. A typical strategy combines host-based unit tests, integration tests on the target and system tests.
- [📝 What is Embedded Testing in Software Testing?](https://www.guru99.com/embedded-software-testing.html)
@@ -1413,6 +1542,8 @@ Testing is an integral part of the embedded systems development process, ensurin
#### 🔵 Test Driven Development (TDD)
Writing tests before the code. In embedded projects the tests usually run on the host with the hardware mocked, which gives fast feedback without flashing a board.
- [📘💎 Test Driven Development for Embedded C - James Grenning](https://www.amazon.com/Driven-Development-Embedded-Pragmatic-Programmers/dp/193435662X)
- [📝 Testing: Unit VS Integration VS Regression VS Acceptance](https://medium.com/@touseefmurtaza1993/testing-unit-vs-integration-vs-regression-vs-acceptance-a3e190cc54dd)
- [📝 Firmware Testing with Renode and GitHub Actions](https://interrupt.memfault.com/blog/test-automation-renode)
@@ -1443,7 +1574,7 @@ Testing is an integral part of the embedded systems development process, ensurin
#### 🔵 CI/CD Pipelines
Continuous Integration (CI) and Continuous Delivery (CD) are software development practices that automate the processof building, testing, and deploying software. CI/CD pipelines are designed to ensure that software changes are deployed quickly and reliably.
Continuous integration builds and tests every change automatically, for example compiling for all targets and running unit tests. Continuous delivery also produces versioned, signed firmware images and can deliver them to devices over the air. Hardware-in-the-loop runners extend CI to real boards.
- [🎞️ Intro to CI/CD Part 1: Getting Started with Docker | Digi-Key Electronics](https://youtu.be/1nxGcfIm-TU)
- [🎞️ Intro to CI/CD Part 2: Getting Started with GitHub Actions | Digi-Key Electronics](https://youtu.be/8pyqbYDYkRs)
@@ -1456,7 +1587,7 @@ Continuous Integration (CI) and Continuous Delivery (CD) are software developmen
#### 🔵 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.
Software-in-the-loop (SIL) and hardware-in-the-loop (HIL) testing validate the functionality and performance of embedded software against a simulated environment. In SIL the code runs on a development machine against a software model of the system; in HIL the real target hardware runs the firmware while a simulator provides the signals of the real world, such as sensors, loads and buses.
- [📝 What Is Hardware-in-the-Loop (HIL)? Differences Between MIL, SIL, PIL, and HIL - MathWorks](https://www.mathworks.com/discovery/hardware-in-the-loop-hil.html)
@@ -1464,7 +1595,7 @@ Software-in-the-loop (SIL) and hardware-in-the-loop (HIL) testing are two crucia
#### 🔵 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).
Embedded systems development is subject to many standards and certifications, which serve as guidelines and benchmarks for the quality, safety and reliability of these systems. They are often developed and maintained by industry bodies such as the International Electrotechnical Commission (IEC) and the Society of Automotive Engineers (SAE).
- [📝 Intro to Embedded Development: Styles and Standards](https://www.allaboutcircuits.com/technical-articles/embedded-programming-styles-and-standards/)
- [📝 Safety Standards and Certifications for Embedded Systems Development](https://www.linkedin.com/pulse/safety-standards-certifications-embedded-systems-development/)
@@ -1484,13 +1615,13 @@ _________________
### ✳️ 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.
Security is particularly challenging in embedded systems because of their resource constraints. They typically run on small, low-power microcontrollers with limited memory and processing power, which makes it difficult to reach the level of security of traditional computing platforms. They also often receive updates and patches rarely, if at all, which leaves them more vulnerable to known vulnerabilities.
- [📝 Embedded Systems Security and TrustZone](https://embeddedsecurity.io/)
#### 🔵 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.
Hardware hacking means attacking a device through its physical interfaces: debug ports (JTAG/SWD, UART), flash chips, bus sniffing and fault injection. Knowing these attacks shows embedded engineers which protections matter, such as locking debug access and encrypting firmware.
@@ -1498,6 +1629,8 @@ Learning hardware hacking helps security professionals understand how embedded s
#### 🔵 Cryptography
Hashing, symmetric and asymmetric encryption and digital signatures, implemented in software or by the hardware accelerators on many microcontrollers, to protect data and authenticate devices and firmware.
- [🎞️👶 Microchip University - Cryptography Primer](https://mu.microchip.com/cryptography-primer)
- [🎞️ Blinky To Bootloader: Bare Metal Programming Series (YouTube Playlist)](https://www.youtube.com/playlist?list=PLP29wDx6QmW7HaCrRydOnxcy8QmW0SNdQ)
- [🎞️ MOOC - Security Part4 : STM32 security in practice (YouTube Playlist)](https://youtube.com/playlist?list=PLnMKNibPkDnF0wt-ZI74SflnsBV4yKzkO)
@@ -1531,7 +1666,7 @@ _________________
### ✳️ 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.
A display needs a user interface that fits small RAM and flash, a limited CPU or GPU and tight latency. Embedded GUI libraries such as LVGL, TouchGFX and Qt provide widgets, drawing and touch handling on top of the display driver.
- [🔗 U8glib library for monochrome displays, version 2](https://github.com/olikraus/u8g2)
- [🔗 LVGL](https://lvgl.io/)
@@ -1542,12 +1677,14 @@ _________________
### ✳️ 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.
IoT devices combine sensors, a microcontroller and a network link, and often run on batteries for years. The embedded work covers connectivity, power budgets, secure provisioning, cloud protocols such as MQTT and over-the-air updates for devices deployed in the field.
- [🎞️👶💎 Microchip University - Design Considerations For Your First IoT Project](https://mu.microchip.com/design-considerations-for-your-first-iot-project)
#### 🔵 Delta Over-The-Air Firmware Update
Updating devices by sending only the differences between firmware versions, which saves bandwidth, time and flash wear.
- [📝 Saving bandwidth with delta firmware updates](https://interrupt.memfault.com/blog/ota-delta-updates)
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.
Edge AI is the ability of devices to perform machine learning tasks on their own, without sending data to a central server, by running small, specialized AI models embedded directly in 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.
The concepts needed before deploying models on devices: training versus inference, models and datasets, and techniques such as quantization that shrink models.
- [📝 A beginner's guide to artificial intelligence and machine learning](https://developer.ibm.com/articles/cc-beginner-guide-machine-learning-ai-cognitive/)
- [📝👶 Introduction to Machine Learning for Coders!](https://course18.fast.ai/ml)
Google's lightweight runtime for running machine learning models on mobile and embedded devices, including a variant for microcontrollers.
- [🎞️ Getting Started with TensorFlow and Keras – Maker.io | Digi-Key Electronics](https://www.youtube.com/watch?v=HCG3hFe1KYY)
- [🎞️ Intro to TensorFlow Lite Part 1: Wake Word Feature Extraction – Maker.io | Digi-Key Electronics](https://www.youtube.com/watch?v=0fn7pj7Dutc)
- [🎞️ Intro to TensorFlow Lite Part 2: Speech Recognition Model Training – Maker.io | Digi-Key Electronics](https://www.youtube.com/watch?v=yv_WVwr6OkI)
#### 🔵 TinyML
Machine learning on microcontrollers, where model size, memory, latency and power are the main constraints.
- [🎞️👶 Intro to TinyML Part 1: Training a Neural Network for Arduino in TensorFlow | Digi-Key Electronics](https://www.youtube.com/watch?v=BzzqYNYOcWc)
- [🎞️👶 Intro to TinyML Part 2: Deploying a TensorFlow Lite Model to Arduino | Digi-Key Electronics](https://www.youtube.com/watch?v=dU01M61RW8s)
- [🎞️ Coursera - Introduction to Embedded Machine Learning](https://www.coursera.org/learn/introduction-to-embedded-machine-learning)
@@ -1590,7 +1733,7 @@ _________________
### ✳️ 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.
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), which allows ECUs from different manufacturers to communicate and work together seamlessly.
@@ -1602,9 +1745,9 @@ AUTOSAR, or AUTomotive Open System ARchitecture, is a global industry standard f
## 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.
At first this was meant to be my personal reading list, but as the list gradually grew, I wondered why not share it with others. So I researched current job postings for embedded engineering roles, selected the most frequent skills and put them on a roadmap. 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](https://github.com/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](https://github.com/m3y54m/Embedded-Engineering-Roadmap-Archived) which is now archived. Early versions of the roadmap were created using [Balsamiq Wireframes](https://balsamiq.com) which is not suitable for these types of diagrams. Today the roadmap is drawn by the interactive explorer in this repository, directly from this README and the map definition.
The idea for this roadmap came from [vazeri / Embedded-Engineering-RoadMap-2018](https://github.com/vazeri/Embedded-Engineering-RoadMap-2018), which was well designed but had some flaws and had not been updated for years. I took that idea, changed the structure of the roadmap and tried to improve it. The initial results can be found in [m3y54m / Embedded-Engineering-Roadmap-Archived](https://github.com/m3y54m/Embedded-Engineering-Roadmap-Archived), which is now archived. Early versions of the roadmap were created using [Balsamiq Wireframes](https://balsamiq.com), which is not suitable for these types of diagrams. Today the roadmap is drawn by the interactive explorer in this repository, directly from this README and the map definition.
## Copyright
@@ -1616,10 +1759,10 @@ This work is licensed under a [Creative Commons Attribution-ShareAlike 4.0 Inter
## Acknowledgement
Special thanks to my friends in the community of Iranian Embedded Engineers in Twitter and [r/embedded](https://www.reddit.com/r/embedded) subreddit for their suggestions that helped in improving this roadmap.
Special thanks to my friends in the community of Iranian Embedded Engineers on Twitter and the [r/embedded](https://www.reddit.com/r/embedded) subreddit for their suggestions that helped improve 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.
If you think this roadmap can be improved in anyway, or you know of good learning resources that could be added here, please open an issue or a pull request. I’ll maintain and update this repository frequently.
The roadmap image and PDF are generated from this repository. Topics, descriptions and learning resources come from this README; where each topic sits on the map and how important it is come from [`explorer/map.json`](explorer/map.json). Edit those files and the interactive explorer in [`explorer/`](explorer) renders the PNG and PDF automatically.
The roadmap image and PDF are generated from this repository. Topics, descriptions and learning resources come from this README; where each topic sits on the map and its learning priority (required, recommended or optional) come from [`explorer/map.json`](explorer/map.json). Edit those files and the interactive explorer in [`explorer/`](explorer) renders the PNG and PDF automatically.
h('li',{},'Map follows the roadmap diagram: topics sit in Software, Hardware or both, and are colored by learning priority, a general guide that varies with your specialty and role.'),
h('li',{},'Click Required, Recommended or Optional in the legend above the map to highlight topics of that priority.'),
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Meysam Parvizi