# Embedded Systems Engineering Roadmap

[![GitHub Repo stars](https://img.shields.io/github/stars/m3y54m/Embedded-Engineering-Roadmap?style=plastic)](https://github.com/m3y54m/Embedded-Engineering-Roadmap/stargazers)
[![GitHub forks](https://img.shields.io/github/forks/m3y54m/Embedded-Engineering-Roadmap?style=plastic)](https://github.com/m3y54m/Embedded-Engineering-Roadmap/forks)
[![GitHub watchers](https://img.shields.io/github/watchers/m3y54m/Embedded-Engineering-Roadmap?style=plastic)](https://github.com/m3y54m/Embedded-Engineering-Roadmap/watchers)
[![GitHub contributors](https://img.shields.io/github/contributors/m3y54m/Embedded-Engineering-Roadmap?style=plastic)](https://github.com/m3y54m/Embedded-Engineering-Roadmap/graphs/contributors)
[![GitHub tag (with filter)](https://img.shields.io/github/v/tag/m3y54m/Embedded-Engineering-Roadmap?style=plastic&label=latest)](https://github.com/m3y54m/Embedded-Engineering-Roadmap/releases/latest)
[![GitHub all releases](https://img.shields.io/github/downloads/m3y54m/Embedded-Engineering-Roadmap/total?style=plastic&label=total%20downloads)](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.

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?

### 📖 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.

▶️ [ISO/IEC/IEEE 24765 Standard:](https://www.iso.org/obp/ui/en/#iso:std:iso-iec-ieee:24765:ed-2:v1:en)

> **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:](https://www.oreilly.com/library/view/making-embedded-systems/9781449308889/)

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

▶️ ["Computer Organization and Embedded Systems" Book:](https://a.co/d/2lt4Svf)

> 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:](https://www.analog.com/en/design-center/glossary/embedded-system.html)

> 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:](https://barrgroup.com/embedded-systems/glossary-e)

> 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

🌐 **[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.

[![Embedded Systems Engineering Roadmap](https://github.com/m3y54m/Embedded-Engineering-Roadmap/releases/latest/download/Embedded-Engineering-Roadmap.png)](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.

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.

🔗 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 priority 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.

<!-- markdownlint-enable MD028 -->

> [!IMPORTANT]  
> **This repository is not affiliated with or financially supported by any content creator, publisher, or organization. We do not endorse or recommend any specific paid resources. Both free and paid resources are included to provide a range of options, allowing you to choose what best suits your needs and preferences.**

## 😕 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.

- [🔗 Random Nerd Tutorials | Learn ESP32, ESP8266, Arduino, and Raspberry Pi](https://randomnerdtutorials.com/)
- [🔗 Last Minute Engineers](https://lastminuteengineers.com/)
- [🔗 51 STM32 Projects & Tutorials for Beginners and Up - Hackster.io](https://www.hackster.io/stm32/projects)
- [🔗 STM32 (STM32F103C8) Projects & Tutorials](https://circuitdigest.com/stm32-projects-and-tutorials)
- [🔗 ElectronicWings Projects](https://www.electronicwings.com/projects)
- [🔗 STM32 Firmware - Phil’s Lab (YouTube Playlist)](https://youtube.com/playlist?list=PLXSyc11qLa1a4Tqbz228dPZfMrs-KRpzA)
- [🔗 Raspberry Pi Based Embedded Project Ideas](https://www.rs-online.com/designspark/raspberry-pi-based-embedded-project-ideas)
- [🔗 Embedded Linux On ARM | Projects](https://www.emertxe.com/embedded-systems/embedded-linux-on-arm/elarm-projects/)
- [🔗 Embedded System Project Series - Artful Bytes (YouTube Playlist)](https://www.youtube.com/playlist?list=PLS_iNJJVTtiRV0DZRDcTHnvAuDrKGPN40)
- [🔗 ESP32 ESP-IDF Tutorials & IoT Protocols](https://esp32tutorials.com/)
- [🔗 flip-card - RP2350 fluid-simulation business card (Rust firmware and PCB design)](https://github.com/Nicholas-L-Johnson/flip-card)
- [🔗 picoZ80 - RP2350 + ESP32 drop-in Z80 CPU replacement for retro computers](https://eaw.app/picoz80/)

### 🔎 Search and Ask!

Use search engines to find the answers to your questions.

- [🔗 Google](https://www.google.com)
- [🔗 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.

- [🔗 DuckDuckGo AI Chat](https://duck.ai/)
- [🔗 Google Gemini](https://gemini.google.com)
- [🔗 ChatGPT](https://chatgpt.com)
- [🔗 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:

- [🔗 Electrical Engineering Stack Exchange](https://electronics.stackexchange.com/)
- [🔗 Reddit · r/embedded](https://www.reddit.com/r/embedded/)

### 💼 Career Development

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:

- [🔗 EmbeddedJobs](https://embedded.jobs/jobs) - A job board focused exclusively on 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.

- [🎞️ DigiKey (YouTube Channel)](https://www.youtube.com/@digikey)
- [🎞️ Coursera - Introduction to Embedded Systems Software and Development Environments](https://www.coursera.org/learn/introduction-embedded-systems)
- [🎞️ Coursera - Embedded Software and Hardware Architecture](https://www.coursera.org/learn/embedded-software-hardware)
- [🎞️ Coursera - ARM Cortex STM32 Deep Dive: Mastering Embedded Systems](https://www.coursera.org/learn/arm-cortex-stm32-deep-dive-mastering-embedded-systems)
- [🎞️ Fastbit Embedded Brain Academy](https://fastbitlab.com/)
- [🎞️ Modern Embedded Systems Programming Course (YouTube Playlist)](https://www.youtube.com/playlist?list=PLPW8O6W-1chwyTzI3BHwBLbGQoPFxPAPM)
- [🎞️ element14 presents (YouTube Channel)](https://www.youtube.com/@element14presents)
- [🎞️ Ben Eater (YouTube Channel)](https://www.youtube.com/@BenEater)
- [🎞️ Phil’s Lab (YouTube Channel)](https://www.youtube.com/@PhilsLab)
- [🎞️ Embedded Systems - Jacob Sorber (YouTube Playlist)](https://www.youtube.com/playlist?list=PL9IEJIKnBJjEcPAz6fss-Hx0TLytCOMVC)
- [🎞️ edX - Embedded Systems - Shape The World: Microcontroller Input/Output](https://learning.edx.org/course/course-v1:UTAustinX+UT.6.10x+3T2022/home)
- [🎞️ edX - Embedded Systems - Shape The World: Multi-Threaded Interfacing](https://www.edx.org/learn/embedded-systems/the-university-of-texas-at-austin-embedded-systems-shape-the-world-multi-threaded-interfacing)
- [🎞️ edX - Embedded Systems Essentials with Arm: Getting Started](https://learning.edx.org/course/course-v1:ArmEducation+EDARMXES1.6x+3T2020/home)
- [🎞️ Low Byte Productions](https://www.youtube.com/@lowbyteproductions)

### 🕹️ 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.

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.

- [🔗 Getting Started with Arduino](https://docs.arduino.cc/learn/starting-guide/getting-started-arduino)
- [🔗👶 Arduino Built-in Examples](https://docs.arduino.cc/built-in-examples/)
- [🔗 Arduino Language Reference](https://docs.arduino.cc/language-reference/)
- [🎞️ All New Arduino R4 WiFi LESSONS for Absolute Beginners (YouTube Playlist)](https://www.youtube.com/playlist?list=PLGs0VKk2DiYyn0wN335MXpbi3PRJTMmex)
- [🎞️ New Arduino Tutorials (YouTube Playlist)](https://youtube.com/playlist?list=PLGs0VKk2DiYw-L-RibttcvK-WBZm8WLEP)
- [🎞️ Arduino in a commercial product?](https://www.youtube.com/watch?v=c5LzsqeSCAc)
- [🎞️ Arduino Project to Product (YouTube Playlist)](https://www.youtube.com/playlist?list=PLEBQazB0HUyQd6Fsf5NQ75M9llbi1_j_8)

### 👨‍🏫 Educational Websites

- [🔗 DeepBlueMbedded](https://deepbluembedded.com/)
- [🔗 Digital Electronics Deeds](https://www.digitalelectronicsdeeds.com/index.html)
- [🔗💎 Interrupt Blog by Memfault](https://interrupt.memfault.com/blog/)
- [🔗💎 EmbeddedRelated.com](https://www.embeddedrelated.com/)
- [🔗 ElectronicWings - Hardware Developers Community](https://www.electronicwings.com/)
- [🔗 EduTecnica (Italian)](https://www.edutecnica.it/)
- [🔗 Microchip University](https://mu.microchip.com/)
- [🔗 Nordic Developer Academy](https://academy.nordicsemi.com/)
- [🔗 Electronics Tutorials](https://www.electronics-tutorials.ws)
- [🔗 SparkFun Learn: Learn at SparkFun Electronics](https://learn.sparkfun.com/)
- [🔗 Adafruit Learning System](https://learn.adafruit.com/)
- [🔗 STM32 World](https://stm32world.com)
- [🔗 ControllersTech](https://controllerstech.com/)
- [🔗 Embedded Systems News - CNX Software](https://www.cnx-software.com/)

### 🗺️ Other Helpful Roadmaps

- [🔗 Embedded Artistry Beginners Roadmap](https://embeddedartistry.com/beginners/)
- [🔗 Embedded Systems Skill Tree](https://github.com/sjpiper145/MakerSkillTree/tree/main/Embedded%20Systems%20Skill%20Tree)
- [🔗 Interactive Embedded Systems Skill Tree (with progress tracking & sync)](https://colonelblacc.github.io/Embedded-Systems-SkillTree)
- [🔗 PCB Design Skill Tree](https://github.com/sjpiper145/MakerSkillTree/tree/main/PCB%20Design%20Skill%20Tree)
- [🔗 FPGA / ASIC Engineering Roadmap](https://github.com/m3y54m/FPGA-ASIC-Roadmap)

### 🛠️ 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)
- [🔗 STM32CubeIDE](https://www.st.com/en/development-tools/stm32cubeide.html)
- [🔗 Microchip Studio for AVR® and SAM Devices](https://www.microchip.com/en-us/tools-resources/develop/microchip-studio)
- [🔗 MPLAB® X IDE](https://www.microchip.com/en-us/tools-resources/develop/mplab-x-ide)
- [🔗 MCUXpresso IDE](https://www.nxp.com/design/software/development-software/mcuxpresso-software-and-tools-/mcuxpresso-integrated-development-environment-ide:MCUXpresso-IDE)

### 👨‍💻 VS Code Extensions

- [🔗 Cortex-Debug](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug)
- [🔗 STM32 VS Code Extension](https://marketplace.visualstudio.com/items?itemName=stmicroelectronics.stm32-vscode-extension)
- [🔗 Espressif IDF](https://marketplace.visualstudio.com/items?itemName=espressif.esp-idf-extension)
- [🔗 MCUXpresso for VS Code](https://marketplace.visualstudio.com/items?itemName=NXPSemiconductors.mcuxpresso)

### 🐜 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 - 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.

## 📚 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.

- [📝 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)

#### 🔵 Communication Skills

- [🔗👶 Technical Writing Courses - Google for Developers](https://developers.google.com/tech-writing)
- [📝💎 How To Ask Questions The Smart Way - Eric S. Raymond](http://www.catb.org/esr/faqs/smart-questions.html)
- [🔗 Software documentation guide - Write the Docs](https://www.writethedocs.org/guide/)

#### 🔵 Problem-Solving Skills & Critical Thinking

- [📘💎 Debugging: The 9 Indispensable Rules for Finding Even the Most Elusive Software and Hardware Problems - David J. Agans](https://debuggingrules.com/)
- [📝 When debugging, your attitude matters - Julia Evans](https://jvns.ca/blog/debugging-attitude-matters/)

#### 🔵 Teamwork & Collaborative Abilities

- [📝 How to Work Well on Teams - Software Engineering at Google](https://abseil.io/resources/swe-book/html/ch02.html)
- [📝 Knowledge Sharing - Software Engineering at Google](https://abseil.io/resources/swe-book/html/ch03.html)
- [🔗💎 Code Review Developer Guide - Google Engineering Practices](https://google.github.io/eng-practices/review/)
- [🔗 Atlassian Team Playbook](https://www.atlassian.com/team-playbook)

#### 🔵 Organizational & Time Management Skills

- [📘💎 Getting Things Done: The Art of Stress-Free Productivity - David Allen](https://gettingthingsdone.com/what-is-gtd/)
- [🎞️👶 Work Smarter, Not Harder: Time Management for Personal & Professional Productivity - Coursera](https://www.coursera.org/learn/work-smarter-not-harder)
- [📝💎 Maker's Schedule, Manager's Schedule - Paul Graham](https://www.paulgraham.com/makersschedule.html)

#### 🔵 Being Self-Driven and Independent

- [🎞️👶 Learning How to Learn - Coursera](https://www.coursera.org/learn/learning-how-to-learn)
- [📝💎 Teach Yourself Programming in Ten Years - Peter Norvig](https://norvig.com/21-days.html)
- [📝💎 How to Do Great Work - Paul Graham](https://paulgraham.com/greatwork.html)
- [📝 You and Your Research - Richard Hamming](https://www.paulgraham.com/hamming.html)

#### 🔵 Adaptability & Patience

- [📘 Mindset: The New Psychology of Success - Carol S. Dweck](https://www.penguinrandomhouse.com/books/44330/mindset-by-carol-s-dweck-phd/)
- [🎞️👶 The power of believing that you can improve - Carol Dweck (TED Talk)](https://www.ted.com/talks/carol_dweck_the_power_of_believing_that_you_can_improve)

_________________

### ✳️ 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/)
- [🔗👶💎 Electronics Tutorials](https://www.electronics-tutorials.ws)
- [📘👶💎 Fundamentals of Electric Circuits - Charles K. Alexander, Matthew Sadiku](https://www.amazon.com/dp/1260226409?ref_=cm_sw_r_cp_ud_dp_Q11YHXNY2BK530RQZC4S)
- [📘👶💎 Principles of Electric Circuits: Conventional Current Version -  Thomas L Floyd, David M. Buchla](https://a.co/d/32T2t2X)
- [🎞️💎 Basic Circuit Theory I (By Prof. Razavi) (YouTube Playlist)](https://www.youtube.com/playlist?list=PL9KyzjPFbwH37w22z-UHVEt37pdJHjZ7x)

#### 🔵 Electronics Fundamentals

The building blocks that appear around every microcontroller: resistors, capacitors, diodes, transistors and op-amps, and how they behave in real circuits.

- [🔗👶💎 Build Electronic Circuits - Øyvind Nydal Dahl](https://www.build-electronic-circuits.com/)
- [🎞️👶 Electronic Basics - GreatScott! (YouTube Playlist)](https://youtube.com/playlist?list=PLAROrg3NQn7cyu01HpOv5BWo217XWBZu0)
- [📘👶 Make: Electronics: Learning by Discovery - Charles Platt](https://a.co/d/fbRoM1R)
- [📘👶💎 Electronic Devices: Conventional Current Version - Thomas Floyd, David Buchla, Steven Wetterling](https://a.co/d/1dsS0vx)
- [📘👶💎 Electronics Fundamentals: Circuits, Devices & Applications - Thomas L Floyd, David M. Buchla, Gary D. Snyder](https://a.co/d/4Ye5m8h)
- [📘👶 Practical Electronics for Inventors - Paul Scherz, Simon Monk](https://a.co/d/1QfSN8j)
- [📘💎 The Art of Electronics -  Paul Horowitz, Winfield Hill](https://artofelectronics.net/)
- [📝 Here’s a Quick Way to Know about Major Electronic Components](https://www.elprocus.com/major-electronic-components/)
- [📘 Encyclopedia of Electronic Components - Charles Platt](https://a.co/d/83cSiU7)
- [🔗 Awesome Electronics: A curated list of electronics resources](https://github.com/kitspace/awesome-electronics)

#### 🔵 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)
- [📘👶💎 Digital Design and Computer Architecture: ARM Edition - Sarah Harris, David Harris](https://a.co/d/4otoVvI)
- [📘👶💎 Digital Design and Computer Architecture: RISC-V Edition - Sarah Harris, David Harris](https://a.co/d/61l7Jtb)
- [📘👶 Digital Fundamentals - Thomas L. Floyd](https://a.co/d/2lgJKNX)

#### 🔵 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 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)
- [📘👶💎 Digital Design and Computer Architecture: RISC-V Edition - Sarah Harris, David Harris](https://a.co/d/61l7Jtb)
- [📘👶 The Elements of Computing Systems - Noam Nisan, Shimon Schocken](https://a.co/d/cX6jkLl)
- [📘 Computer Organization and Embedded Systems - Carl Hamacher, Zvonko Vranesic, Safwat Zaky, Naraig Manjikian](https://a.co/d/2lt4Svf)
- [📘 Embedded Systems Architecture - Tammy Noergaard](https://www.oreilly.com/library/view/embedded-systems-architecture/9780123821966/)
- [📘 Embedded Systems Architecture - Daniele Lacamera](https://www.packtpub.com/product/embedded-systems-architecture-second-edition/9781803239545)
- [📘 The Definitive Guide to ARM® Cortex®-M0 and Cortex-M0+ Processors - Joseph Yiu](https://www.oreilly.com/library/view/the-definitive-guide/9780128032787/)
- [📘 The Definitive Guide to ARM® Cortex®-M3 and Cortex®-M4 Processors - Joseph Yiu](https://www.oreilly.com/library/view/the-definitive-guide/9780124080829/)
- [🔗 Build an 8-bit computer from scratch](https://eater.net/8bit/)

_________________

### ✳️ Using Test Equipment

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.

- [🎞️ Instrument Basics: Logic Analyzer](https://youtu.be/u1DYs2I-_lU)

#### 🔵 Oscilloscope

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)
- [🎞️ Understanding EMI Debugging with Oscilloscopes](https://www.youtube.com/watch?v=x1rn5YNLmVw)

_________________

### ✳️ 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.

- [🎞️👶 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.

- [🎞️👶💎 Hardware Design - Phil’s Lab (YouTube Playlist)](https://www.youtube.com/playlist?list=PLXSyc11qLa1YhVCZ5xWPuPsE5MkgEy5TF)
- [🎞️ Electronic Circuit Design - IFE - TU Graz (YouTube Playlist)](https://www.youtube.com/playlist?list=PLLpZ1DoEuR9tbV8r8bMSI94znm6pRB905)
- [🎞️ 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)
- [🎞️👶 Create PCBs for Rapid Prototyping - DigiKey (YouTube Playlist)](https://www.youtube.com/playlist?list=PLEBQazB0HUyRVK1RpHIjyjuTxn5srz6XM)
- [🎞️👶💎 PCB Design for Beginners - Altium Academy (YouTube Playlist)](https://www.youtube.com/playlist?list=PL3aaAq2OJU5EsYtNwTPHNO3RHNJN34FbO)
- [🎞️ How to Make a Raspberry Pi Compute Module 4 Carrier Board - DigiKey (YouTube Playlist)](https://www.youtube.com/playlist?list=PLEBQazB0HUyRwjr761b-MLNEu8FA8WKSG)
- [🎞️💎 How To Learn PCB Design (My Thoughts, Journey, and Resources) - Phil's Lab #87](https://youtu.be/aODkA2mrimQ)
- [🎞️👶 KiCad 6 STM32 PCB Design Full Tutorial - Phil's Lab #65](https://youtu.be/aVUqaB0IMh4)
- [🎞️👶 Intro to KiCad - DigiKey (YouTube Playlist)](https://www.youtube.com/watch?v=vaCVh2SAZY4&list=PLEBQazB0HUyR24ckSZ5u05TZHV9khgA1O)
- [🎞️💎 PCB Design for EMI & SI - Phil's Lab #64](https://www.youtube.com/watch?v=VtzPL8wQ8-E)
- [🎞️💎 PCB Design for Advanced Users (YouTube Playlist)](https://youtube.com/playlist?list=PL3aaAq2OJU5EWfYT_Z93tc9pBF_Sidba_)
- [🎞️💎 PCB Knowledge [PCB Production Tips By PCBWay] (YouTube Playlist)](https://www.youtube.com/playlist?list=PLzxdr3n97eVtHuh7gnDzMubuO836kvfu7)
- [🎞️💎 Udemy – High-Speed Board Design Course System On Module - EsteemPCB](https://www.udemy.com/course/highspeed_board_design_course)
- [🎞️💎 Udemy – Advanced Hardware and PCB Design Masterclass 2022](https://www.udemy.com/course/advanced-hardware-design-course)
- [🎞️💎 9 Simple Tricks to Improve EMC / EMI on Your Boards - Practical examples (with Min Zhang)](https://www.youtube.com/watch?v=Lf51sx6sC0I)
- [🎞️💎 Many EMC Tips to Help You Design Better PCB Boards (with Keith Armstrong)](https://www.youtube.com/watch?v=gHF5JyJF-N4)
- [🔗 LearnEMC - EMC Resources](https://learnemc.com/emc-resources)
- [🔗 A Better Way to Build PCBs - Flux AI](https://www.flux.ai/p/)
- [🔗 EasyEDA](https://easyeda.com/)
- [🔗 KiCad - Free and open-source schematic capture and PCB design software](https://www.kicad.org/)
- [🔗 Fritzing](https://fritzing.org/)
- [🔗 Cirkit Designer](https://www.cirkitdesigner.com/)

#### 🔵 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)
- [🎞️ How to Solder Through-Hole Components - Another Teaching Moment | DigiKey Electronics](https://www.youtube.com/watch?v=DJH7VLGJ4fs)
- [🎞️ How to Solder QFN MLF Package by Hand (Using a Hot Air Rework Station) | Digi-Key Electronics](https://youtu.be/X3Rc1s6EpSI)
- [🎞️ From Solderless Breadboard to Soldered Circuit - Electronics with Becky Stern | Digi-Key Electronics](https://www.youtube.com/watch?v=F9Krq7seV1g)

_________________

### ✳️ 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.

- [🔗 FPGA / ASIC Engineering Roadmap](https://github.com/m3y54m/FPGA-ASIC-Roadmap)
- [📝 What are FPGAs?](https://hackaday.io/project/27550-the-hobbyists-guide-to-fpgas/log/68114-what-are-fpgas)
- [🎞️ FPGA vs. Microcontroller: How to choose the right one for your project](https://www.youtube.com/watch?v=jblpHUCPQYs)
- [🎞️👶 Introduction to FPGA (YouTube Playlist)](https://youtube.com/playlist?list=PLEBQazB0HUyT1WmMONxRZn9NmQ_9CIKhb)
- [🔗👶 FPGA Fundamentals - Nandland](https://nandland.com/fpga-101/)
- [🎞️💎 Coursera – FPGA Design for Embedded Systems Specialization](https://www.coursera.org/specializations/fpga-design)
- [📘💎 A Hands-On Guide to Designing Embedded Systems - Adam Taylor, Dan Binnun, Saket Srivastava](https://www.amazon.com/Hands-Guide-Designing-Embedded-Systems/dp/1630816833)

_________________

### ✳️ 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.

#### 🔵 Discrete Mathematics

Discrete mathematics is the theoretical basis of computer science and engineering. The parts most useful to embedded engineers are logic and switching algebra (digital circuit design), automata theory (state machines and protocols), combinatorics, coding theory (data transmission and audio/video codecs) and modular arithmetic (checksums and cryptography).

- [🎞️ Coursera - Introduction to Discrete Mathematics for Computer Science Specialization](https://www.coursera.org/specializations/discrete-mathematics)
- [📘👶 Open Access Discrete Mathematics Books by LibreTexts](https://math.libretexts.org/Bookshelves/Combinatorics_and_Discrete_Mathematics)
- [📘👶 Essential Discrete Mathematics for Computer Science - Harry Lewis, Rachel Zax](https://dl.acm.org/doi/book/10.5555/3388468)
- [📘👶 Guide to Discrete Mathematics - Gerard O'Regan, Springer](https://link.springer.com/book/10.1007/978-3-030-81588-2)
- [📘💎 Bridge to Abstract Mathematics, AMS](https://bookstore.ams.org/view?ProductCode=TEXT/22)
- [📘💎 Discrete Mathematics and its applications by Rosen](https://dl.acm.org/doi/book/10.5555/579402)
- [📘💎 Discrete Mathematics with Applications by Susanna S. Epp](https://dl.acm.org/doi/book/10.5555/1941983)
- [📘💎 Switching and Finite Automata Theory, Cambridge Press](https://dl.acm.org/doi/10.5555/1708070)
- [📘💎 The Mathematics of Cellular Automata by Jane Hawkins, AMS](https://bookstore.ams.org/stml-108)

#### 🔵 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)
- [🎞️ Udemy – Embedded Systems State Machines & Data Structures](https://www.udemy.com/course/embedded-systems-state-machines-data-structures-like-a-pro/)
- [🔗 Data Structures in C](https://www.sanfoundry.com/c-programming-examples-data-structures/)
- [🎞️ Data Structures - Full Course Using C and C++](https://www.youtube.com/watch?v=B31LgI4Y4DQ)
- [🔗 Hello Algo](https://www.hello-algo.com/en/)

#### 🔵 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/)
- [🎧💎 Making Embedded Systems: Design Patterns for Great Software - Elecia White (Audio Book)](https://www.audiobooks.com/audiobook/making-embedded-systems-design-patterns-for-great-software/814297)
- [🔗 Design Patterns - Refactoring Guru](https://refactoring.guru/design-patterns)

#### 🔵 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)
- [🎞️💎 Event-Driven Programming (YouTube Playlist)](https://www.youtube.com/playlist?list=PLPW8O6W-1chx8Y7Oq2gOE0NUPXmQxu2Wr)
- [🎞️💎 Udemy - Embedded System Design using UML State Machines](https://www.udemy.com/course/embedded-system-design-using-uml-state-machines/)
- [📝 “Input-Driven” vs. Event-Driven State Machines](https://www.state-machine.com/input-driven-vs-event-driven-state-machines)
- [📝 State Machines for Event-Driven Systems](https://barrgroup.com/embedded-systems/how-to/state-machines-event-driven-systems)
- [📘 Practical UML Statecharts in C/C++ by Miro Samek](https://www.amazon.sg/Practical-UML-Statecharts-Event-Driven-Programming/dp/0750687061)

#### 🔵 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)
- [🎞️ Dynamic memory allocation in C - malloc calloc realloc free](https://www.youtube.com/watch?v=xDVC3wKjS64&t=140s)
- [📝 What is Memory Leak in C/C++? How can we avoid?](https://aticleworld.com/what-is-memory-leak-in-c-c-how-can-we-avoid/)
- [📝 Understanding Memory Management in Rust](https://medium.com/geekculture/understanding-memory-management-in-rust-a341cfce9807)
- [📝 Memory Management in Python](https://realpython.com/python-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

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)
- [🎞️💎 Microchip University - C Programming: Linked List Data Structures](https://mu.microchip.com/c-programming-linked-list-data-structures)
- [🎞️💎 Microchip University - C Programming Callbacks](https://mu.microchip.com/c-programming-callbacks)
- [🎞️👶 C Programming for Beginners | Full Course](https://www.youtube.com/watch?v=ssJY5MDLjlo)
- [🎞️ C Programming Tutorials (YouTube Playlist)](https://www.youtube.com/playlist?list=PLA1FTfKBAEX4hblYoH6mnq0zsie2w6Wif)
- [📘💎 The C Programming Language -  Brian W. Kernighan, Dennis M. Ritchie](https://www.amazon.com/dp/0131103628?ref_=cm_sw_r_cp_ud_dp_KRZ8M1WTXWVG0HMSRBXA)
- [🔗👶 C by Example](https://www.cbyexample.com/)
- [📘👶 The Little Book of C](https://little-book-of.github.io/c/books/en-US/book.html)
- [📘👶 Beej's Guide to C Programming](https://beej.us/guide/bgc/)
- [📘 C How to Program -  Paul Deitel, Harvey Deitel](https://deitel.com/c-how-to-program-9-e/)
- [📘 Effective C - An Introduction to Professional C Programming - Robert C. Seacord](https://nostarch.com/Effective_C)
- [📘 Modern C - Jens Gustedt](https://gustedt.gitlabpages.inria.fr/modern-c/)
- [🔗 Embedded C Coding Standard](https://barrgroup.com/free-downloads)
- [🔗 newlib C Library Documentation](https://sourceware.org/newlib/docs.html)
- [🔗 The GNU C Library (glibc)](https://www.gnu.org/software/libc/documentation.html)
- [📝 From Zero to main(): Bare metal C](https://interrupt.memfault.com/blog/zero-to-main-1)
- [📝 From Zero to main(): Bootstrapping libc with Newlib](https://interrupt.memfault.com/blog/bootstrapping-libc-with-newlib)
- [🎞️👶 Learn C Programming and OOP with Dr. Chuck](https://www.youtube.com/watch?v=PaPN51Mm5qQ)
- [📘 Extreme C -  Kamran Amini](https://www.packtpub.com/free-ebook/extreme-c/9781789343625)
- [🎞️👶 Coursera - C Programming with Linux Specialization](https://www.coursera.org/specializations/c-programming-linux)

#### 🔵 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/)
- [🎞️💎 C++ in Constrained Environments - Bjarne Stroustrup - CppCon 2022](https://www.youtube.com/watch?v=2BuJjaGuInI)
- [🎞️👶 C++ Tutorial for Beginners - Full Course](https://www.youtube.com/watch?v=vLnPwxZdW4Y)
- [🎞️ C++ by The Cherno (YouTube Playlist)](https://youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb)
- [🎞️👶💎 Udemy - Beginning C++ Programming - From Beginner to Beyond](https://www.udemy.com/course/beginning-c-plus-plus-programming/)
- [🎞️💎 CppCon Conferences - YouTube](https://www.youtube.com/@CppCon/playlists)
- [📘💎 A Tour of C++ (3rd Edition) - Bjarne Stroustrup](https://www.stroustrup.com/tour3.html)
- [📘💎 The C++ programming Language (C++11) - Bjarne Stroustrup](https://www.stroustrup.com/4th.html)
- [📘💎 Programming -- Principles and Practice Using C++ (3rd Edition) - Bjarne Stroustrup](https://www.stroustrup.com/programming.html)
- [📘💎 Real-Time C++: Efficient Object-Oriented and Template Microcontroller Programming - Christopher Kormanyos](https://link.springer.com/book/10.1007/978-3-662-62996-3)
- [📘 Effective Modern C++ - Scott Meyers](https://www.oreilly.com/library/view/effective-modern-c/9781491908419/)

##### Additional resources from Bjarne Stroustrup, creator of C++

- [🎞️👶 The Essence of C++ by Bjarne Stroustrup - YouTube](https://www.youtube.com/watch?v=86xWVb4XIyE)
- [🎞️👶💎 Delivering Safe C++ by Bjarne Stroustrup - CppCon 2023](https://www.youtube.com/watch?v=I8UvQKvOSSw)

#### 🔵 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)
- [📝 How to Use Inline Assembly Language in C Code](https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html)
- [📘 Raspberry Pi Assembly Language Programming : ARM Processor Coding](https://www.amazon.com/Raspberry-Assembly-Language-Programming-Processor/dp/1484252861)
- [🔗 Battery info program for x86-64 Linux laptops in 298 bytes of machine code](https://github.com/meribold/btry)

#### 🔵 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/)
- [📘👶💎 Python Crash Course - Eric Matthes](https://a.co/d/hSMTJwE)

##### 🔶 Python for Microcontrollers

- [🔗 MicroPython - Python for microcontrollers](https://micropython.org/)
- [🔗 MicroPython 101 | Arduino Documentation](https://docs.arduino.cc/micropython/)
- [🔗 CircuitPython](https://circuitpython.org/)
- [📝 The Pros and Cons of Designing Embedded Systems with MicroPython](https://www.designnews.com/electronics-test/pros-and-cons-designing-embedded-systems-micropython)
- [📝 Programming the ESP32 with MicroPython](https://wolles-elektronikkiste.de/en/programming-the-esp32-with-micropython)

#### 🔵 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)
- [🔗 Community Rust support projects for STM32 microcontrollers](https://github.com/stm32-rs)
- [🔗 Rust on ESP Community](https://github.com/esp-rs)
- [🎞️ Embedded Rust su ESP32 (Italian) - YouTube Playlist](https://www.youtube.com/playlist?list=PLT--ndZEB54ek5_Zv6x6WCioh5m35zh5i)
- [📝 Rust on STM32: Getting started](https://jonathanklimt.de/electronics/programming/embedded-rust/rust-on-stm32-2/)
- [📝 From Zero to main(): Bare metal Rust](https://interrupt.memfault.com/blog/zero-to-main-rust-1)
- [📝 Writing an OS in Rust - Philipp Oppermann's blog](https://os.phil-opp.com/)
- [📝 Kernel Driver with Rust in 2022](https://not-matthias.github.io/posts/kernel-driver-with-rust/)
- [🔗 Rustlings - Small exercises to get you used to reading and writing Rust code!](https://rustlings.rust-lang.org/)
- [🔗 Learn Rust the Effective Way](https://www.rustfinity.com/)

#### 🔵 Zig

- [📝 Testing Zig for embedded development](https://www.kuon.ch/post/2022-06-22-zig-embed/)
- [🔗 Zig Embedded Group](https://github.com/ZigEmbeddedGroup)
- [🔗 MicroZig - Unified abstraction layer and HAL for several microcontrollers](https://github.com/ZigEmbeddedGroup/microzig)
- [📝 Zig Bare Metal Programming on STM32F103 — Booting up](https://maldus512.medium.com/zig-bare-metal-programming-on-stm32f103-booting-up-b0ecdcf0de35)

_________________

### ✳️ 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.

- [📝 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/)
- [📝 How to Read a Microcontroller Datasheet: Introduction and First Steps](https://www.allaboutcircuits.com/technical-articles/how-to-read-a-microcontroller-datasheet-introduction-and-first-steps2/)
- [📘👶 Make: AVR Programming - Elliot Williams](https://www.oreilly.com/library/view/make-avr-programming/9781449356484/)
- [🎞️👶💎 NewbieHack - Microcontroller Tutorial - A Beginners Guide (AVR)](https://www.youtube.com/playlist?list=PLE72E4CFE73BD1DE1)
- [🎞️👶 Getting Started with STM32 and Nucleo (YouTube Playlist)](https://youtube.com/playlist?list=PLEBQazB0HUyRYuzfi4clXsKUSgorErmBv)
- [📘💎 Mastering STM32 - Carmine Noviello](https://leanpub.com/mastering-stm32-2nd)
- [📘💎 Developing IoT Projects with ESP32 - Vedat Ozan Oner](https://www.packtpub.com/product/developing-iot-projects-with-esp32-second-edition/9781803237688)
- [🎞️👶 Intro to Raspberry Pi Pico and RP2040 (YouTube Playlist)](https://www.youtube.com/playlist?list=PLEBQazB0HUyQO6rJxKr2umPCgmfAU-cqR)
- [🔗 Getting started with STM32: STM32 step-by-step](https://wiki.st.com/stm32mcu/wiki/Category:Getting_started_with_STM32_:_STM32_step_by_step)
- [🎞️ Getting Started With AVR (YouTube Playlist)](https://www.youtube.com/playlist?list=PLtQdQmNK_0DRhBWYZ32BEILOykXLpJ8tP)
- [🎞️ Fundamentals of Microcontrollers - Arduino bare-metal breakdown (YouTube Playlist)](https://www.youtube.com/playlist?list=PLNyfXcjhOAwOF-7S-ZoW2wuQ6Y-4hfjMR)
- [🎞️ Bare Metal Embedded Programming: Theory and Practice Using STM32 (YouTube Playlist)](https://www.youtube.com/playlist?list=PL4cGeWgaBTe155QQSQ72DksLIjBn5Jn2Z)
- [📘 Beginning STM32: Developing with FreeRTOS, libopencm3 and GCC - Warren Gay](https://link.springer.com/book/10.1007/978-1-4842-3624-6)
- [🎞️ Udemy – Microcontroller Embedded C Programming: Absolute Beginners](https://www.udemy.com/course/microcontroller-embedded-c-programming/)
- [🎞️ Udemy – Embedded Systems STM32 Low-Layer APIs(LL) Driver Development](https://www.udemy.com/course/embedded-systems-stm32-low-level-ll-driver-development/)
- [🎞️ Udemy – Embedded Systems STM32 HAL APIs Driver Development](https://www.udemy.com/course/embedded-systems-stm32-hal-apis-driver-development/)
- [📘 Embedded System Design with ARM Cortex-M Microcontrollers: Applications with C, C++ and MicroPython - Cem Ünsalan, Hüseyin Deniz Gürhan, Mehmet Erkin Yücel](https://link.springer.com/book/10.1007/978-3-030-88439-0)
- [📘💎 Embedded Systems Design using the MSP430FR2355 LaunchPad - Brock J. LaMeres](https://link.springer.com/book/10.1007/978-3-030-40574-8)
- [📘💎 Building Embedded Systems: Programmable Hardware - Changyi Gu](https://link.springer.com/book/10.1007/978-1-4842-1919-5)
- [🔗 Awesome Embedded: A curated list of awesome embedded programming](https://github.com/nhivp/Awesome-Embedded)

#### 🔵 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)
- [🎞️ STM32 TIMERS (YouTube Playlist)](https://www.youtube.com/playlist?list=PLfIJKC1ud8gjLZBzjE3kKBMDEH_lUc428)

#### 🔵 PWM (Pulse Width Modulation)

A digital output whose duty cycle is adjustable, used to control motor speed, LED brightness and power converters.

- [🎞️ What is PWM?](https://www.youtube.com/watch?v=B_Ysdv1xRbA)
- [📝 Pulse-width Modulation (PWM) Timers in Microcontrollers](https://www.allaboutcircuits.com/technical-articles/introduction-to-microcontroller-timers-pwm-timers/)
- [🎞️ STM32 Guide #3: PWM + Timers](https://www.youtube.com/watch?v=AjN58ceQaF4)

#### 🔵 RTC  (Real Time Clock)

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)
- [🎞️ WATCHDOGS in STM32 || IWDG and WWDG || CubeIDE](https://www.youtube.com/watch?v=AelNsnpfbcM)

#### 🔵 Interrupts

Let hardware events preempt the running code immediately. Priorities, latency and short handlers are central to responsive firmware.

- [🎞️ Polling/Interrupt/DMA differences explained easily](https://www.youtube.com/watch?v=LNPBr3WvuNg)
- [🎞️ Level Up Your Arduino Code: External Interrupts](https://www.youtube.com/watch?v=J61_PKyWjxU)
- [🎞️ Tutorial 10: Peripheral 2 - Nested Vector Interrupt controller (NVIC) in STM32](https://www.youtube.com/watch?v=qwebM-YaSU4)
- [🎞️ Tutorial 11: LAB - External Interrupt ( EXTI ) Interfacing in STM32 using STM32CUBEMX](https://www.youtube.com/watch?v=oJc0seuBbzI)
- [🎞️ Tutorial 12: Interrupt Priorities in STM32](https://www.youtube.com/watch?v=aXLJD4qJmtk)

#### 🔵 DMA

Moves data between peripherals and memory without the CPU, freeing it for other work and sustaining high-rate transfers from ADCs, SPI or UART.

- [🎞️ Introduction to Direct Memory Access (DMA)](https://www.youtube.com/watch?v=M16l_ymlfcs)
- [🎞️ STM32 DMA PT 1](https://www.youtube.com/watch?v=yvLHtXJ_KSg)
- [🎞️ STM32 DMA PT 2](https://www.youtube.com/watch?v=Kb8dX18xYuo)
- [🎞️ Getting Started With STM32 & Nucleo Part 4: Working with ADC and DMA - Maker.io](https://www.youtube.com/watch?v=EsZLgqhqfO0)
- [🎞️ STM32 UART DMA and IDLE LINE || Receive unknown length DATA](https://www.youtube.com/watch?v=Bo6MC5A8uTE)

#### 🔵 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)
- [🎞️ Tutorial 8: MCU Clocks configuration in STM32 using STM32CUBEMX](https://www.youtube.com/watch?v=y8yNsWpQiTM)
- [🎞️ Clock sources and PLL in ARM Cortex M4](https://www.youtube.com/watch?v=2ou8FQ_7PdI)

#### 🔵 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)
- [🎞️ Blinky To Bootloader: Bare Metal Programming Series (YouTube Playlist)](https://www.youtube.com/playlist?list=PLP29wDx6QmW7HaCrRydOnxcy8QmW0SNdQ)
- [📝 Simple AVR Bootloader tutorial](https://www.pocketmagic.net/simple-avr-bootloader-tutorial/)
- [🎞️💎 Udemy – STM32Fx Microcontroller Custom Bootloader Development](https://www.udemy.com/course/stm32f4-arm-cortex-mx-custom-bootloader-development/)
- [📝💎 Device Firmware Update Cookbook](https://interrupt.memfault.com/blog/device-firmware-update-cookbook)

_________________

### ✳️ Interfaces, Protocols & Communication Technologies

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/)
- [📝👶 Basics of Wired Embedded Protocols](https://piolabs.com/blog/engineering/wired-embedded-protocols-basics.html)
- [🎞️ PROTOCOLS: UART - I2C - SPI - Serial communications #001](https://www.youtube.com/watch?v=IyGwvGzrqp8)

##### 🔶 UART

- [🎞️👶 Understanding UART](https://www.youtube.com/watch?v=sTHckUyxwp8)
- [🎞️ how does UART work??? (explained clearly)](https://www.youtube.com/watch?v=V6m2skVlsQI)
- [🎞️ Basics of UART Communication | UART Frame Structure | RS 232 Basics | Part1](https://www.youtube.com/watch?v=JuvWbRhhpdI)
- [🎞️ Understanding UART Communication Programming | UART Peripherals | Part 2](https://www.youtube.com/watch?v=QmjKRwgddxw)
- [🎞️ The RS-232 protocol](https://www.youtube.com/watch?v=AHYNxpqKqwo)

##### 🔶 I2C

- [🎞️👶 Understanding I2C](https://www.youtube.com/watch?v=CAvawEcxoPU)
- [📝 I2C in a Nutshell](https://interrupt.memfault.com/blog/i2c-in-a-nutshell)
- [🎞️ STM32 I2C SLAVE (YouTube Playlist)](https://www.youtube.com/playlist?list=PLfIJKC1ud8gj_P7Qb28aTr0t92uk_vwg0)

##### 🔶 SPI

- [🎞️👶 Understanding SPI](https://www.youtube.com/watch?v=0nVNwozXsIc)
- [🎞️ SPI: The serial peripheral interface](https://www.youtube.com/watch?v=MCi7dCBhVpQ)
- [🎞️ Getting Started with STM32 and Nucleo Part 5: How to Use SPI | Digi-Key Electronics](https://www.youtube.com/watch?v=eFKeNPJq50g)

##### 🔶 SDIO

- [📝 SDIO Protocol](https://prodigytechno.com/blog/device/sdio-protocol/)
- [📝 Interface SD CARD with SDIO in STM32](https://controllerstech.com/interface-sd-card-with-stm32-via-sdio-4bit-mode/)
- [🔗 SDIO Card Slave Driver - ESP32 - Technical Documents](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/sdio_slave.html)

##### 🔶 I3C

- [🎞️ What is I3C®?](https://www.youtube.com/watch?v=g3TBNHec5Ec)
- [🔗 MIPI I3C Sensor Specification](https://www.mipi.org/specifications/i3c-sensor-specification)
- [📝 I3C Protocol: Understanding and Debug](https://prodigytechno.com/blog/device/mipi-i3c-protocol-debug/)
- [🎞️ MIPI I3C Basic - The next generation sensor interface enabling low-power IoT applications](https://www.youtube.com/watch?v=xWKxZp_9RFQ)

##### 🔶 1-Wire

- [🎞️ 1-Wire® Technology Overview](https://www.youtube.com/watch?v=CjH-OztKe00)

#### 🔵 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/)
- [🎞️ Building a Digital Music Player with I2S?! What is I2S! EB#45](https://www.youtube.com/watch?v=qNLvoSQCx60)
- [🔗 UM11732 - I2S bus specification](https://www.nxp.com/docs/en/user-manual/UM11732.pdf)

##### 🔶 PCM

- [🔗 HUAWEI LGA Module - PCM Audio Design Guide](https://www.paoli.cz/out/media/HUAWEI%20LGA%20Module%20PCM%20Audio%20Design%20Guide-V100R001_04(1).pdf)
- [📝 PCM Terminology and Concepts](https://larsimmisch.github.io/pyalsaaudio/terminology.html)

#### 🔵 Display & Camera Protocols

Interfaces for displays and image sensors, from simple control buses to the high-speed MIPI links used with application processors.

##### 🔶 SCCB

- [🔗 SCCB Specification (PDF)](https://people.ece.cornell.edu/land/courses/ece4760/FinalProjects/f2021/jfw225_aei23_dsb298/jfw225_aei23_dsb298/SCCBSpec_AN.pdf)
- [📝 OmniVision OV5640 Software Application Notes (PDF)](https://dlscorp.com/wp-content/uploads/2018/04/OmniVision-OV5640-Software-Application-Notes.pdf)

##### 🔶 MIPI CSI-2

- [🔗 MIPI Camera Serial Interface 2](https://www.mipi.org/specifications/csi-2)
- [🎞️ Tutorial: MIPI CSI-2](https://www.youtube.com/watch?v=8REu_h7bzHM)
- [🔗 AN13573 - i.MX 8/RT MIPI DSI/CSI-2](https://www.nxp.com/docs/en/application-note/AN13573.pdf)

##### 🔶 MIPI DSI

- [🔗 MIPI Display Serial Interface](https://www.mipi.org/specifications/dsi)
- [🔗 AN4860 - Introduction to DSI host on STM32 MCUs and MPUs](https://www.st.com/resource/en/application_note/an4860-introduction-to-dsi-host-on-stm32-mcus-and-mpus-stmicroelectronics.pdf)

##### 🔶 HDMI

- [🎞️ TI Precision Labs - Video Interface: What are HDMI & Dual-Mode DisplayPort?](https://www.youtube.com/watch?v=jCO7Up1rzJc)
- [🎞️ HDMI 2.1 & TMDS Crash Course - ENMU EET 457 - Presentation](https://www.youtube.com/watch?v=5acgSK0kWTE)

#### 🔵 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)
- [📝 Bluetooth Basics](https://learn.sparkfun.com/tutorials/bluetooth-basics/all)
- [📝 Bluetooth Low Energy: A Primer](https://interrupt.memfault.com/blog/bluetooth-low-energy-a-primer)
- [📝 A Practical Guide to BLE Throughput](https://interrupt.memfault.com/blog/ble-throughput-primer)
- [🎞️ SparkFun According to Pete #49 - How Bluetooth Works](https://www.youtube.com/watch?v=zJqGLWQGyvk)
- [🔗 Bluetooth Low Energy Fundamentals - Nordic Semiconductor](https://academy.nordicsemi.com/courses/bluetooth-low-energy-fundamentals/)
- [🔗 Bluetooth API - ESP-IDF Programming Guide](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/bluetooth/index.html)

##### 🔶 Wi-Fi

- [🎞️ 802.11 How WiFi Works - Wireless Networks | Computer Networks Ep. 7.3 | Kurose & Ross](https://www.youtube.com/watch?v=vvhEnr52UOU)
- [🎞️ 802.11 Frame Analysis](https://www.youtube.com/watch?v=ITAJb3v5VKQ)
- [🔗 Wi-Fi Driver - ESP-IDF Programming Guide](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/wifi.html)
- [📝 ESP32 Set an Access Point (AP) using ESP-IDF](https://esp32tutorials.com/esp32-access-point-ap-esp-idf/)
- [📝 ESP32 ESP-IDF Connect with WiFi – Station Mode Example](https://esp32tutorials.com/esp32-esp-idf-connect-wifi-station-mode-example/)

##### 🔶 LoRa / LoRaWAN

- [📝 The Arduino Guide to LoRa® and LoRaWAN®](https://docs.arduino.cc/learn/communication/lorawan-101)
- [🔗💎 The Things Fundamentals on LoRaWAN!](https://www.thethingsnetwork.org/docs/lorawan/)
- [📝 What are LoRa® and LoRaWAN®?](https://www.semtech.com/lora/what-is-lora)
- [🎞️ #112 LoRa / LoRaWAN De-Mystified / Tutorial](https://www.youtube.com/watch?v=hMOwbNUpDQA)
- [🔗 ESP32 with LoRa using Arduino IDE – Getting Started](https://randomnerdtutorials.com/esp32-lora-rfm95-transceiver-arduino-ide/)

##### 🔶 Zigbee

- [🎞️ What is ZIGBEE And How It Works?](https://www.youtube.com/watch?v=THtVeaxnd9E)
- [🎞️ How to take advantage of Zigbee and Bluetooth LE 5.2 on STM32WB wireless MCUs - Webinar Replay](https://www.youtube.com/watch?v=2sYEPykOaLQ)

##### 🔶 Thread

- [🔗 OpenThread - An open-source implementation of Thread®](https://openthread.io/)
- [🎞️ What is Thread? Low-power IoT Networking for Smart Home Devices | Digi-Key Electronics](https://youtu.be/5CauESYB9-A)
- [🔗 OpenThread - ESP-IDF Programming Guide](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/openthread.html)

##### 🔶 Matter

- [🎞️ What is Matter? Unifying IoT Devices for the Smart Home | Digi-Key Electronics](https://youtu.be/vJIEfih9bl0)

##### 🔶 UWB

- [📘👶 Ultra-Wideband For Dummies - Qorvo](https://www.qorvo.com/design-hub/ebooks/ultra-wideband-for-dummies)
- [🔗 FiRa Consortium - Advancing Ultra-Wideband (UWB) Technology](https://www.firaconsortium.org/)
- [📝 Ultra-wideband - Wikipedia](https://en.wikipedia.org/wiki/Ultra-wideband)

#### 🔵 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)
- [🎞️ How does Modbus Communication Protocol Work?](https://www.youtube.com/watch?v=JBGaInI-TG4)
- [🎞️ MODBUS STM32 (YouTube Playlist)](https://www.youtube.com/playlist?list=PLfIJKC1ud8ggRvaEsMjSEDazoBAnY4MUv)

##### 🔶 RS485

- [🎞️ What is RS485 and How it's used in Industrial Control Systems?](https://www.youtube.com/watch?v=3wgKcUDlHuM)
- [🎞️ What is RS-485?](https://www.youtube.com/watch?v=bt9Px51eP6s)

##### 🔶 EtherCAT

- [🎞️ Microchip University - An Introduction to EtherCAT®, EtherCAT P and the Microchip LAN925x family of Slave Controllers](https://mu.microchip.com/an-introduction-to-ethercat-ethercat-p-and-the-microchip-lan925x-family-of-slave-controllers)

##### 🔶 Profinet

- [🎞️👶 How PROFINET Works? A Beginner's Guide - PI North America](https://us.profinet.com/webinar/how-profinet-works-a-beginners-guide/)
- [🎞️ PROFINET Video Series](https://www.profinet.com/profinet-explained/explanatory-videos)
- [🔗 PROFINET University](https://profinetuniversity.com/)

##### 🔶 CoAP & MQTT

- [🎞️ #144 Internet Protocols: CoAP vs MQTT, Network Sniffing, and preparation for IKEA Tradfri Hacking](https://www.youtube.com/watch?v=pfG8uEDZj5g)
- [🎞️ MQTT vs. CoAP | Comparison of IoT Protocols](https://www.youtube.com/watch?v=0CORpVSUQe0)
- [🎞️ Simple ESP32 IoT Sensor Node Tutorial: WiFi Enabled MQTT Sensor Data Node](https://www.youtube.com/watch?v=x5A5S0hoyJ0)

#### 🔵 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)
- [📝 How the Ethernet Protocol Works – A Complete Guide](https://www.freecodecamp.org/news/the-complete-guide-to-the-ethernet-protocol/)
- [🎞️ What is an Ethernet PHY?](https://www.youtube.com/watch?v=JH3cMYErmKI)
- [🎞️ The Data Link Layer, MAC Addressing, and the Ethernet Frame](https://www.youtube.com/watch?v=_b4dXKB8Pt8)
- [🎞️ Microchip University - Serializer/Deserializer (SerDes) Basics for Your Next Microchip Ethernet PHY Design](https://mu.microchip.com/serializerdeserializer-serdes-basics-for-your-next-microchip-ethernet-phy-design)
- [🎞️ Microchip University - Ethernet Switch Fundamentals](https://mu.microchip.com/ethernet-switch-fundamentals)

##### 🔶 USB

- [🎞️👶 Microchip University - Introduction to USB 2.0](https://mu.microchip.com/introduction-to-usb-20)
- [🎞️👶 Microchip University - USB 3 Fundamentals](https://mu.microchip.com/usb-3-fundamentals)
- [🎞️ Training - USB 101 - Introduction to USB](https://www.youtube.com/watch?v=5S6ZPmtPzRA)
- [🔗 USB 101: An Introduction to Universal Serial Bus 2.0](https://www.infineon.com/assets/row/public/documents/cross-divisions/42/infineon-an57294-usb-101-an-introduction-to-universal-serial-bus-2.0-applicationnotes-en.pdf)
- [🎞️ How does a USB keyboard work?](https://youtu.be/wdgULBpRoXk)
- [🎞️ How does USB device discovery work?](https://www.youtube.com/watch?v=N0O5Uwc3C0o)
- [🎞️ MOOC - STM32 USB training (YouTube Playlist)](https://www.youtube.com/playlist?list=PLnMKNibPkDnFFRBVD206EfnnHhQZI4Hxa)
- [🎞️ Microchip University - USB2 Hub Fundamentals](https://mu.microchip.com/usb2-hub-fundamentals)
- [🔗 Beyond Logic - USB in a NutShell](https://www.beyondlogic.org/usbnutshell/usb1.shtml)
- [📝 USB for Software Developers: An introduction to writing userspace USB drivers](https://werwolv.net/posts/usb_for_sw_devs/)

##### 🔶 PCIe

- [🎞️ What is PCIe?](https://www.youtube.com/watch?v=L9qXjmJdQXY)
- [🎞️ PCIe QuickLearn (YouTube Playlist)](https://www.youtube.com/playlist?list=PL9B4edd-p2ajuP4dBHcnhtHKoZKkoR1R4)
- [🎞️ PCIe Protocol (YouTube Playlist)](https://www.youtube.com/playlist?list=PLZe4P0P_9Cosd0i2ha_QRdWlR1iZ0yVG4)

#### 🔵 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)
- [📝👶 CAN bus in 2024: Operation, Advantages and Recent Developments](https://www.parlezvoustech.com/en/bus-can-2024-technologie-avantages-evolutions/)
- [🎞️👶 CAN Bus: Serial Communication - How It Works?](https://www.youtube.com/watch?v=JZSCzRT9TTo&t=21s)
- [🎞️👶 CAN Bus: A Beginners Guide Part 1](https://www.youtube.com/watch?v=YBrU_eZM110)
- [🎞️👶 CAN Bus: A Beginners Guide Part 2](https://www.youtube.com/watch?v=z5CVljiLhvc)
- [🎞️💎 Microchip University - Designing and Implementing a CAN FD Network](https://mu.microchip.com/designing-and-implementing-a-can-fd-network)
- [🎞️ Improving my electric longboard with a CAN Bus! What can the CAN Bus do? EB#44](https://www.youtube.com/watch?v=PL0TPdrhMuI)
- [🎞️ CAN Bus, OBD2 & J1939 Explained (YouTube Playlist)](https://www.youtube.com/playlist?list=PLpV68vjf4Xo4vZ_SjJ6tTlomYm-k18vDZ)
- [🎞️ J1939 Explained - A Simple Intro [v2.0 | 2021]](https://www.youtube.com/watch?v=vlqxu9ojbHg)
- [🎞️ Unified Diagnostic Services (UDS) Explained - A Simple Intro [2022]](https://www.youtube.com/watch?v=CV_B8tJgI5E)

##### 🔶 LIN

- [📝👶 LIN Bus Explained - A Simple Intro - CSS Electronics](https://www.csselectronics.com/pages/lin-bus-protocol-intro-basics)
- [📝 Local Interconnect Network - Wikipedia](https://en.wikipedia.org/wiki/Local_Interconnect_Network)

##### 🔶 MOST

- [📝 MOST Bus - Wikipedia](https://en.wikipedia.org/wiki/MOST_(bus))
- [🔗 MOST Cooperation - Specifications](https://www.mostcooperation.com/specifications/)

##### 🔶 FlexRay

- [📝 FlexRay Automotive Communication Bus Overview - NI](https://www.ni.com/en/shop/seamlessly-connect-to-third-party-devices-and-supervisory-system/flexray-automotive-communication-bus-overview.html)
- [📝 FlexRay - Wikipedia](https://en.wikipedia.org/wiki/FlexRay)

#### 🔵 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.

- [🎞️ Networking Fundamentals - Practical Networking (YouTube Playlist)](https://www.youtube.com/playlist?list=PLIFyRwBY_4bRLmKfP1KnZA6rZbRHtxmXi)
- [🎞️ 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)
- [🎞️ UDP doesn't suck! It's the BEST L4 protocol for THESE types of applications...](https://www.youtube.com/watch?v=LaDRWycC7Iw)
- [🎞️ Networking tutorial - Ben Eater (YouTube Playlist)](https://www.youtube.com/playlist?list=PLowKtXNTBypH19whXTVoG3oKSuOcw_XeW)
- [📘💎 Hands-On Network Programming with C - Lewis Van Winkle](https://www.amazon.com/dp/1789349869)
- [📘💎 Network Algorithmics - George Varghese, Jun Xu](https://www.oreilly.com/library/view/network-algorithmics-2nd/9780128099865/)
- [🔗 tcpdump & libpcap libraries](https://www.tcpdump.org/)
- [🔗 lwIP - A Lightweight TCP/IP stack](https://savannah.nongnu.org/projects/lwip/)
- [🔗 lwIP (ESP-IDF)](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/lwip.html)
- [🔗 Developing applications on STM32Cube with LwIP TCP/IP stack](https://www.st.com/resource/en/user_manual/um1713-developing-applications-on-stm32cube-with-lwip-tcpip-stack-stmicroelectronics.pdf)
- [📝 Understanding Traceroute](https://tech.stonecharioteer.com/posts/2026/traceroute/)

#### 🔵 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)

##### 🔶 LTE-M & NB-IoT

- [🔗 Cellular IoT Fundamentals - Nordic Semiconductor](https://academy.nordicsemi.com/courses/cellular-iot-fundamentals/)

_________________

### ✳️ 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.

- [📝 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

- [🎞️ QSPI in STM32 || Write and Read || N25Q](https://www.youtube.com/watch?v=xIfh_uYy-OU)
- [🎞️ QSPI in STM32 || Boot from EXT Memory || XIP || N25Q](https://www.youtube.com/watch?v=gAyuF20ok8c)
- [🎞️ Flash Memory in Embedded Linux Systems](https://www.youtube.com/watch?v=hdwMvwJIV-Y)

##### 🔶 eMMC

- [🎞️ What is a eMMC? Intro, Comparing to Other Storage, and Upgrading. SSD, M.2](https://www.youtube.com/watch?v=vGatKmqYxEA)

##### 🔶 SD Card

- [🎞️ Interfacing with an SD Card](https://www.youtube.com/watch?v=g40tUdjZ-Sk)

#### 🔵 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)
- [🎞️ SDRAM Hardware & Firmware Tutorial (STM32) - Phil's Lab #80](https://www.youtube.com/watch?v=h28D4AaPSjg)
- [🎞️ SDRAM in STM32 || MT48LC4](https://www.youtube.com/watch?v=QnDenqvzwyE)

#### 🔵 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.

- [📝 Flash filesystems](https://hugh712.gitbooks.io/embeddedsystem/content/flash_filesystems.html)
- [📝 Block filesystems](https://hugh712.gitbooks.io/embeddedsystem/content/block_filesystems.html)
- [📝 Understanding the UBI File System in Embedded Devices](https://serhack.me/articles/understanding-ubi-file-system-embedded-devices-reolink/)
- [📝 UBI File System](https://docs.kernel.org/filesystems/ubifs.html)
- [📝 JFFS : The Journalling Flash File System](https://sourceware.org/jffs2/jffs2-html/)
- [📝 Preventing Filesystem Corruption In Embedded Linux](https://www.embeddedts.com/assets/preventing-filesystem-corruption-in-embedded-linux)
- [🔗 LittleFS - A high-integrity embedded file system](https://github.com/littlefs-project/littlefs)
- [🔗 SPIFFS - Wear-leveled SPI flash file system for embedded devices](https://github.com/pellepl/spiffs)
- [🔗 EEPROM File System (EEFS)](https://github.com/nasa/EEFS)

_________________

### ✳️ 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.

- [🔗👶 Wokwi - Online ESP32, STM32, Arduino Simulator](https://wokwi.com/)
- [🔗👶 SimulIDE Circuit Simulator](https://simulide.com/)
- [🔗👶 Digital logic designer and circuit simulator designed for educational purposes](https://github.com/hneemann/Digital)
- [🔗👶 EveryCircuit](https://everycircuit.com/)
- [🔗👶 Circuit Simulator Applet](https://www.falstad.com/circuit/)
- [🔗👶 Tinkercad](https://www.tinkercad.com/)
- [🔗👶 Voltsim](https://www.voltsimulator.com/)
- [🔗 Velxio - Arduino & Embedded Board Emulator](https://github.com/davidmonterocrespo24/velxio)

#### 🔵 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.

- [🔗 QEMU’s documentation](https://www.qemu.org/docs/master/index.html)
- [📝 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)
- [📝 Emulating a Raspberry Pi in QEMU](https://interrupt.memfault.com/blog/emulating-raspberry-pi-in-qemu)
- [📝👶 Building an ARM Embedded Linux System in QEMU](https://github.com/dchithinh/mastering-embeded-linux-programming)

#### 🔵 Renode

An open-source framework that simulates whole embedded systems, including peripherals and multiple nodes, which makes firmware testable in CI without boards.

- [🔗 Renode - GitHub Repo](https://github.com/renode/renode)
- [🔗 Renode - Documentation](https://renode.readthedocs.io/en/latest/)
- [🔗 Renode - Running your first demo](https://renode.readthedocs.io/en/latest/introduction/demo.html)
- [📝 Cortex-M MCU Emulation with Renode](https://interrupt.memfault.com/blog/intro-to-renode)
- [📝 A simple guide to get started on renode](https://github.com/tarciszera/renode_guide)
- [🎞️ Using CI-based workflow with Renode in bringing TensorFlow Lite to Zephyr](https://www.youtube.com/watch?v=jF94cXPoZZg)

_________________

### ✳️ 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.

- [🎞️💎 Coursera - Embedding Sensors and Motors Specialization](https://www.coursera.org/specializations/embedding-sensors-motors)

#### 🔵 Sensors

- [📝 Calibrating Sensors](https://learn.adafruit.com/calibrating-sensors)
- [📝 DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180](https://randomnerdtutorials.com/dht11-vs-dht22-vs-lm35-vs-ds18b20-vs-bme280-vs-bmp180/)
- [🎞️ Getting Started With STM32 and Nucleo Part 2: How to Use I2C to Read Temperature Sensor TMP102](https://www.youtube.com/watch?v=isOekyygpR8)
- [🎞️ GPS Module and STM32 || NEO 6M || Get coordinates, Date, Time, Speed, etc.](https://www.youtube.com/watch?v=tq_RoaPLahk)
- [🎞️ Interface MPU6050/GY-521 with STM32 || LCD 20x4 || CubeMx || HAL || SW4STM](https://www.youtube.com/watch?v=xxphp9wDnHA)
- [📝 Arduino with PIR Motion Sensor](https://randomnerdtutorials.com/arduino-with-pir-motion-sensor/)
- [📝 Complete Guide for Ultrasonic Sensor HC-SR04 with Arduino](https://randomnerdtutorials.com/complete-guide-for-ultrasonic-sensor-hc-sr04/)
- [🎞️ Electronic Basics #15: Temperature Measurement (Part 1) || NTC, PT100, Wheatstone Bridge](https://youtu.be/1U4fep_qAeo?si=Q2FF__EXONN-xN5M)

#### 🔵 Actuators

- [📝 Adafruit Motor Selection Guide](https://learn.adafruit.com/adafruit-motor-selection-guide)
- [🎞️ DC Motor Speed Controller PWM With Potentiometer Using STM32](https://www.youtube.com/watch?v=8QpegVuV_AQ)
- [📝 All About Stepper Motors](https://learn.adafruit.com/all-about-stepper-motors)
- [📝 Using Servos With CircuitPython and Arduino](https://learn.adafruit.com/using-servos-with-circuitpython)
- [🎞️ Electronic Basics #25: Servos and how to use them](https://youtu.be/J8atdmEqZsc?si=bH_xoIwnAsNU5_lD)
- [🎞️ Electronic Basics #24: Stepper Motors and how to use them](https://youtu.be/bkqoKWP4Oy4?si=kvhwykmFZ0UnLDJ7)
- [🎞️ Electronic Basics #18: DC & Brushless DC Motor + ESC](https://youtu.be/UteZJ_7C4Mg?si=uADPmCaucyWXd8Xe)

_________________

### ✳️ Digital Signal Processing

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)
- [🎞️ Digital Signal Processing (ECSE-4530) Lectures, Fall 2014 (YouTube Playlist)](https://youtube.com/playlist?list=PLuh62Q4Sv7BUSzx5Jr8Wrxxn-U10qG1et)
- [🎞️ Udemy – Digital Signal Processing (DSP) From Ground Up in C](https://www.udemy.com/course/digital-signal-processing-dsp-from-ground-uptm-in-c/)
- [📘 Real-Time Digital Signal Processing: Fundamentals, Implementations and Applications - Sen M. Kuo, Bob H. Lee, Wenshun Tian](https://www.wiley.com/en-us/Real+Time+Digital+Signal+Processing%3A+Fundamentals%2C+Implementations+and+Applications%2C+3rd+Edition-p-9781118414323)
- [📘 Real-Time Digital Signal Processing from MATLAB to C with the TMS320C6x DSPs - Thad B. Welch, Cameron H.G. Wright, Michael G. Morrow](https://www.routledge.com/Real-Time-Digital-Signal-Processing-from-MATLAB-to-C-with-the-TMS320C6x/Welch-Wright-Morrow/p/book/9780367736453)
- [📘 Schaum's Outline of Signals and Systems - Hwei P. Hsu](https://www.amazon.com/dp/126045424X)
- [📘💎 Digital Signal Processing - John G. Proakis, Dimitris K. Manolakis](https://a.co/d/75P5PiE)
- [📘 Introduction to Computer Music](https://composerprogrammer.com/introductiontocomputermusic.pdf)

#### 🔵 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)
- [🎞️ STM32 Fast Fourier Transform (CMSIS DSP FFT) - Phil's Lab #111](https://youtu.be/d1KvgOwWvkM)

_________________

### ✳️ 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)
- [📘💎 Control Systems Engineering - Norman S. Nise](https://www.wiley.com/en-us/Control+Systems+Engineering%2C+8th+Edition-p-9781119474227)
- [📘💎 Modern Control Systems - Richard C. Dorf, Robert H. Bishop](https://www.pearson.com/en-us/subject-catalog/p/modern-control-systems/P200000003484/9780137307098)
- [🔗 Kalman Filter](https://kalmanfilter.net/)

#### 🔵 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)
- [🎞️ PID Controller Explained](https://www.youtube.com/watch?v=fv6dLTEvl74)
- [🎞️ Understanding PID Control (YouTube Playlist)](https://youtube.com/playlist?list=PLn8PRpmsu08pQBgjxYFXSsODEF3Jqmm-y)
- [🎞️ PID Controller Implementation in Software - Phil's Lab #6](https://www.youtube.com/watch?v=zOByx3Izf5U)

#### 🔵 MATLAB / Simulink

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/)

_________________

### ✳️ 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

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/)
- [📘👶 Operating Systems: From 0 to 1](https://github.com/tuhdo/os01/blob/master/Operating_Systems_From_0_to_1.pdf)
- [🔗 An operating system](https://github.com/roscopeco/anos)
- [📝 Porting Mac OS X to the Nintendo Wii](https://bryankeller.github.io/2026/04/08/porting-mac-os-x-nintendo-wii.html)
- [📘💎 Operating Systems: Three Easy Pieces -  Remzi H Arpaci-Dusseau, Andrea C Arpaci-Dusseau](https://pages.cs.wisc.edu/~remzi/OSTEP/)
- [📘💎 Modern Operating Systems - Andrew S. Tanenbaum, Herbert Bos](https://www.pearson.com/en-us/subject-catalog/p/modern-operating-systems/P200000003295)
- [📝 Writing an OS in Rust - Philipp Oppermann's blog](https://os.phil-opp.com/)
- [🔗 Operating System development tutorials in Rust on the Raspberry Pi](https://github.com/rust-embedded/rust-raspberrypi-OS-tutorials)

#### 🔵 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

- [📝 Bare-metal and RTOS Based Embedded Systems](https://microcontrollerslab.com/difference-bare-metal-and-rtos-based-embedded-systems/)
- [📝 RTOS vs. Bare Metal: Navigating Performance, Complexity, and Efficiency](https://weston-embedded.com/support/media-articles/119-rtos-vs-bare-metal-navigating-performance-complexity-and-efficiency)
- [📝 The Pros and Cons of RTOS vs Bare Metal: Which Will You Choose?](https://medium.com/@lanceharvieruntime/the-pros-and-cons-of-rtos-vs-bare-metal-which-will-you-choose-756e33ba6df7)
- [📝 FreeRTOS vs Linux for Embedded Systems](https://www.bytesnap.com/news-blog/freertos-vs-linux-embedded-systems/)
- [🔗 tinyOS RTOS](https://github.com/cmc-labo/tinyos-rtos)
- [🔗 Real-Time Systems Concepts](https://micrium.atlassian.net/wiki/spaces/osiidoc/pages/163855/Real-Time+Systems+Concepts)
- [🔗 RTOS Fundamentals](https://www.freertos.org/Documentation/01-FreeRTOS-quick-start/01-Beginners-guide/01-RTOS-fundamentals)
- [📝 A Simple Scheduler via an Interrupt-driven Actor Model](https://interrupt.memfault.com/blog/hardware-actor-scheduler)
- [📝 ARM Cortex-M RTOS Context Switching](https://interrupt.memfault.com/blog/cortex-m-rtos-context-switching)
- [🎞️ RTOS (YouTube Playlist)](https://www.youtube.com/playlist?list=PLPW8O6W-1chyrd_Msnn4LD6LBs2slJITs)
- [🎞️ Beyond the RTOS (YouTube Playlist)](https://www.youtube.com/playlist?list=PLPW8O6W-1chytjkg63-tM7MI0BvGxxPIP)

##### 🔶 FreeRTOS

- [🔗 FreeRTOS - Market leading RTOS](https://www.freertos.org)
- [🎞️👶 Introduction to RTOS (YouTube Playlist)](https://www.youtube.com/playlist?list=PLEBQazB0HUyQ4hAPU1cJED6t3DU0h34bz)
- [📘💎 Mastering the FreeRTOS Real Time Kernel - a Hands On Tutorial Guide](https://www.freertos.org/Documentation/02-Kernel/07-Books-and-manual/01-RTOS_book)
- [🎞️👶 Microchip University - FreeRTOS Simplified: A Beginner's Guide to Develop and Debug FreeRTOS Applications](https://mu.microchip.com/freertos-simplified)
- [🎞️ Getting Started With STM32 and Nucleo Part 3: FreeRTOS - How To Run Multiple Threads w/ CMSIS-RTOS](https://www.youtube.com/watch?v=CdpgqpuPSyQ)
- [📘 Hands-On RTOS with Microcontrollers: Building real-time embedded systems using FreeRTOS, STM32 MCUs, and SEGGER debug tools - Brian Amos](https://a.co/d/11MSPlo)
- [📘 Beginning STM32: Developing with FreeRTOS, libopencm3 and GCC - Warren Gay](https://link.springer.com/book/10.1007/978-1-4842-3624-6)
- [🔗 SafeRTOS - Safety Critical Real-Time OS](https://www.freertos.org/Partners/Software/SafeRTOS)

##### 🔶 Zephyr

- [🔗 Zephyr® Project](https://www.zephyrproject.org/)
- [📝💎 Getting Started With Zephyr](https://www.embeddedrelated.com/showarticle/1505.php)
- [🔗 Zephyr: Tutorial for Beginners](https://maksimdrachov.github.io/zephyr-rtos-tutorial/)
- [📝 Why We Moved from FreeRTOS to Zephyr RTOS](https://www.zephyrproject.org/why-we-moved-from-freertos-to-zephyr-rtos/)
- [🔗 nRF Connect SDK](https://academy.nordicsemi.com/courses/nrf-connect-sdk-fundamentals/)
- [🎞️ ESP32 on Zephyr OS (YouTube Playlist)](https://www.youtube.com/playlist?list=PLEQVp_6G_y4iFfemAbFsKw6tsGABarTwp)
- [🎞️💎 Introduction to Zephyr - Digikey (YouTube Playlist)](https://www.youtube.com/playlist?list=PLEBQazB0HUyTmK2zdwhaf8bLwuEaDH-52)

##### 🔶 μC/OS / Micriμm OS

- [🔗 Micriμm OS](https://www.silabs.com/developers/micrium)
- [🔗 µC/OS-III Documentation](https://micrium.atlassian.net/wiki/spaces/osiiidoc/overview)
- [📘 µC/OS-III Books](https://weston-embedded.com/micrium-books)
- [📘💎 µC/OS-II Documentation (Previously published as a book titled "MicroC/OS-II: The Real-Time Kernel")](https://micrium.atlassian.net/wiki/spaces/osiidoc/overview)

##### 🔶 NuttX

- [🔗 NuttX - The Apache Software Foundation](https://nuttx.apache.org/)
- [🔗 NuttX Documentation](https://nuttx.apache.org/docs/latest/)
- [🎞️ Getting Started to NuttX (YouTube Playlist)](https://www.youtube.com/playlist?list=PLd73yQk5Fd8JEsVD-lhwYRQKVu6glfDa8)

##### 🔶 RT-Thread

- [🔗 RT-Thread | An Open Source Embedded Real-time Operating System](https://www.rt-thread.io/)
- [🔗 RT-Thread document center](https://www.rt-thread.io/document/site/)
- [🎞️ RT-Thread Beginners Guide (YouTube Playlist)](https://youtube.com/playlist?list=PLXUV89C_M3G5KVw2IerI-pqApdSM_IaZo)

##### 🔶 Mbed OS

- [🔗 Mbed OS](https://github.com/ARMmbed/mbed-os)
- [🔗 Mbed CE - Community-maintained continuation of Mbed OS](https://mbed-ce.dev/)

##### 🔶 QNX

- [🔗 BlackBerry QNX: Embedded OS, Support, and Services](https://blackberry.qnx.com/en)
- [🔗 QNX Product Documentation](https://www.qnx.com/developers/docs/index.html)

##### 🔶 VxWorks

- [🔗 VxWorks | Industry Leading RTOS for Embedded Systems](https://www.windriver.com/products/embedded/vxworks)
- [🔗 VxWorks Documentation](https://docs.windriver.com/category/os_vxworks?labelkey=os_vxworks)
- [🎞️ VxWORKS-RTOS - Kumar M (YouTube Playlist)](https://www.youtube.com/playlist?list=PLyp1I7W35-q34sYWBlBg8xgoqsizZ57P7)

##### 🔶 Eclipse ThreadX (formerly Azure RTOS)

- [🔗 Eclipse ThreadX - Advanced Embedded RTOS](https://threadx.io/)
- [🔗 Eclipse ThreadX documentation (formerly Azure RTOS docs)](https://github.com/eclipse-threadx/rtos-docs)
- [🔗 Eclipse ThreadX source code](https://github.com/eclipse-threadx/threadx)

#### 🔵 Embedded Linux

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/)
- [🎞️👶 Introduction to Embedded Linux (YouTube Playlist)](https://youtube.com/playlist?list=PLEBQazB0HUyTpoJoZecRK6PpDG31Y7RPB)
- [📝 Mastering Embedded Linux Series (Part 1) - George Hilliard's blog](https://www.thirtythreeforty.net/posts/mastering-embedded-linux-part-1-concepts/)
- [📘💎 Mastering Embedded Linux Programming - Chris Simmonds](https://www.packtpub.com/product/mastering-embedded-linux-programming-third-edition/9781789530384)
- [🎞️💎 Coursera - Advanced Embedded Linux Development Specialization](https://www.coursera.org/specializations/advanced-embedded-linux-development)
- [🔗 Linux From Scratch - step-by-step instructions for building your own custom Linux system](https://www.linuxfromscratch.org/)
- [🔗 Automotive Grade Linux (AGL)](https://docs.automotivelinux.org/)
- [🔗 Real Time Linux and `PREEMPT_RT` Patch](https://wiki.linuxfoundation.org/realtime/start)

##### 🔶 Linux Kernel

- [📘👶 Linux Kernel Development - Robert Love](https://www.oreilly.com/library/view/linux-kernel-development/9780768696974/)
- [📘💎 The Linux Programming Interface - Michael Kerrisk](https://man7.org/tlpi/)
- [📘 How Linux Works - Brian Ward](https://nostarch.com/howlinuxworks3)

##### 🔶 Linux Device Drivers

- [📘💎 Linux Device Drivers -  Jonathan Corbet, Alessandro Rubini, Greg Kroah-Hartman](https://lwn.net/Kernel/LDD3/)
- [📘 The Linux Kernel Module Programming Guide](https://sysprog21.github.io/lkmpg/)
- [🔗👶 Kernel modules - Linux Kernel Teaching Labs](https://linux-kernel-labs.github.io/refs/heads/master/labs/kernel_modules.html)
- [📘 Mastering Linux Device Driver Development - John Madieu](https://www.packtpub.com/product/mastering-linux-device-driver-development/9781789342048)
- [📝 Kernel Driver with Rust in 2022](https://not-matthias.github.io/posts/kernel-driver-with-rust/)

##### 🔶 U-Boot

- [🔗 The U-Boot Documentation](https://docs.u-boot.org/en/latest/)
- [🔗 Barebox](https://www.barebox.org/doc/latest/index.html)

##### 🔶 Buildroot

- [🔗 Buildroot Documentation](https://buildroot.org/docs.html)
- [🎞️ Introduction to Embedded Linux Part 1 - Buildroot | Digi-Key Electronics](https://www.youtube.com/watch?v=9vsu67uMcko)
- [📝 Building Tiny Raspberry Pi Linux Images With Buildroot](https://rickcarlino.com/2021/building-tiny-raspberry-pi-linux-images-with-buildroot.html)

##### 🔶 Yocto

- [🔗 Yocto Project Quick Build](https://docs.yoctoproject.org/brief-yoctoprojectqs/index.html)
- [🔗💎 Yocto Project Documentation](https://docs.yoctoproject.org/index.html)
- [🎞️ Introduction to Embedded Linux Part 2 - Yocto Project | Digi-Key Electronics](https://www.youtube.com/watch?v=2-PwskQrZac&t=7s)
- [🎞️ Yocto Project Tutorial Series (Basic to Advance) (YouTube Playlist)](https://www.youtube.com/playlist?list=PLwqS94HTEwpQmgL1UsSwNk_2tQdzq3eVJ)
- [🎞️ Udemy – Embedded Linux using Yocto](https://www.udemy.com/course/embedded-linux-using-yocto/)
- [📘💎 Embedded Linux Systems with the Yocto Project - Rudolf J.Streif](https://www.oreilly.com/library/view/embedded-linux-systems/9780133443301/)
- [📘 Embedded Linux Development using Yocto Project Cookbook - Alex Gonzalez](https://www.oreilly.com/library/view/embedded-linux-development/9781788399210/)
- [📘 Bootlin Embedded Linux, Kernel, drivers, Yocto, Buildroot and Graphics Training](https://bootlin.com/training/)
- [🔗 meta-raspberrypi - Yocto/OpenEmbedded layer for Raspberry Pi boards](https://meta-raspberrypi.readthedocs.io/en/latest/)

##### 🔶 Embedded Android

Embedded Android builds on Embedded Linux: the device runs a Linux kernel with Android-specific additions, and the Android Open Source Project (AOSP) adds its own build system, hardware abstraction layers (HALs) and framework on top. Learn Embedded Linux first, then how AOSP is built, ported to a board and extended with HALs and native (NDK) code.

- [🔗💎 Android Open Source Project](https://source.android.com)
- [🔗👶 AOSP Architecture Overview](https://source.android.com/docs/core/architecture)
- [🔗 Try Android Development - Download, Build and Flash AOSP](https://source.android.com/docs/setup/start)
- [🔗 Android Kernel Overview](https://source.android.com/docs/core/architecture/kernel)
- [🔗 Hardware Abstraction Layer (HAL) Overview](https://source.android.com/docs/core/architecture/hal)
- [🔗 Get Started with the Android NDK](https://developer.android.com/ndk/guides)
- [📘💎 Embedded Android - Karim Yaghmour](https://www.oreilly.com/library/view/embedded-android/9781449327958/)
- [📘 Android System Development Training (Slides and Labs) - Bootlin](https://bootlin.com/doc/legacy/android/)
- [🔗 Android Automotive](https://source.android.com/docs/automotive)

#### 🔵 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)
- [📘💎 Programming with POSIX Threads - David Butenhof](https://a.co/d/9R6DswF)
- [📘 C++ Concurrency in Action - Anthony Williams](https://www.manning.com/books/c-plus-plus-concurrency-in-action)

##### 🔶 High-Performance Computing (HPC)

- [🔗 Parallel Programming and Performance Optimization With OpenMP](https://passlab.github.io/InteractiveOpenMPProgramming/)
- [🎞️ Introduction to OpenMP - Tim Mattson (Intel) (YouTube Playlist)](https://youtube.com/playlist?list=PLLX-Q6B8xqZ8n8bwjGdzBJ25X2utwnoEG)
- [🔗 OpenCL Tutorials](https://www.intel.com/content/www/us/en/developer/articles/training/opencl-tutorials.html)
- [🔗 CUDA Programming Guide](https://docs.nvidia.com/cuda/cuda-programming-guide/index.html)
- [📝👶 An Even Easier Introduction to CUDA - NVIDIA Technical Blog](https://developer.nvidia.com/blog/even-easier-introduction-cuda/)
- [🔗👶 GPU Puzzles - Solve puzzles, learn CUDA](https://github.com/srush/GPU-Puzzles)

#### 🔵 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/)
- [📘 Extreme C -  Kamran Amini | Chapter 19: Single-Host IPC and Sockets](https://www.packtpub.com/free-ebook/extreme-c/9781789343625)
- [🎞️ Udemy – Multi-Threading and IPC with Qt 5 C++](https://www.udemy.com/course/multi-threading-and-ipc-with-qt-c-plus-plus/)
- [📝 D-Bus Tutorial](https://dbus.freedesktop.org/doc/dbus-tutorial.html)

#### 🔵 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

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.

- [📝 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)
- [🎞️ STM32 + SWD + ST-Link + CubeIDE | Debugging on Custom Hardware Tutorial - Phil's Lab #4](https://www.youtube.com/watch?v=qMUzLU636s8)
- [📝 Diving into JTAG protocol. Part 1 — Overview](https://medium.com/@aliaksandr.kavalchuk/diving-into-jtag-protocol-part-1-overview-fbdc428d3a16)
- [📝 Diving into JTAG protocol. Part 2 — Debugging](https://medium.com/@aliaksandr.kavalchuk/diving-into-jtag-protocol-part-2-debugging-56a566db3cf8)
- [📝 Diving into JTAG protocol. Part 3 — Boundary Scan](https://medium.com/@aliaksandr.kavalchuk/diving-into-jtag-part-3-boundary-scan-17f9975ecc59)

#### 🔵 GDB

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.

- [📝 Advanced GDB Usage](https://interrupt.memfault.com/blog/advanced-gdb)
- [📝 How do breakpoints even work?](https://interrupt.memfault.com/blog/cortex-m-breakpoints)
- [🔗 GNU GDB Debugger Command Cheat Sheet](http://www.yolinux.com/TUTORIALS/GDB-Commands.html)
- [🔗 gdbgui - A browser-based frontend to gdb (gnu debugger)](https://www.gdbgui.com/)
- [🎞️ everyone needs to stop using print debugging (do THIS instead)](https://www.youtube.com/watch?v=3T3ZDquDDVg)
- [🎞️ GDB is REALLY easy! Find Bugs in Your Code with Only A Few Commands](https://www.youtube.com/watch?v=Dq8l1_-QgAc)
- [📝 Introduction to ARM Semihosting](https://interrupt.memfault.com/blog/arm-semihosting)

#### 🔵 OpenOCD

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.

- [🔗 OpenOCD - GitHub repository](https://github.com/openocd-org/openocd)
- [🎞️ 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)

_________________

### ✳️ Build System

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

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)
- [📝 From Zero to main(): Demystifying Firmware Linker Scripts](https://interrupt.memfault.com/blog/how-to-write-linker-scripts-for-firmware)
- [📝 Bare Metal - From zero to blink](https://www.linuxembedded.fr/2021/02/bare-metal-from-zero-to-blink)
- [🔗 Keil MDK & µVision](https://www.keil.com/)
- [🔗 IAR Embedded Workbench](https://www.iar.com)

#### 🔵 Make / CMake

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)
- [🔗 CMake Tutorial](https://cmake.org/cmake/help/latest/guide/tutorial/index.html)
- [🎞️ How to CMake Good (YouTube Playlist)](https://youtube.com/playlist?list=PLK6MXr8gasrGmIiSuVQXpfFuE1uPT615s)
- [📝👶 The most thoroughly commented embedded CMakeLists file](https://dnedic.github.io/blog/the-most-thoroughly-commented-embedded-cmakelists/)
- [🔗 A lightweight build and workflow tool for C/C++](https://github.com/randerson112/craft)

#### 🔵 Bash Scripting

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 cheatsheet](https://devhints.io/bash)
- [🎞️ Bash Scripting Tutorial for Beginners](https://www.youtube.com/watch?v=tK9Oc6AEnR4)

#### 🔵 Docker

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.

- [🔗 Docker Docs](https://docs.docker.com/get-started/)
- [🔗 Docker Cheat Sheet](https://docs.docker.com/get-started/docker_cheatsheet.pdf)
- [📝👶 Docker for Dummies](https://dev.to/stevenmcgown/docker-for-dummies-2bff)
- [🎞️ Introduction to Docker for the Embedded Developer](https://www.youtube.com/watch?v=Fz7ou-VBk-w)
- [🎞️ Intro to CI/CD Part 1: Getting Started with Docker | Digi-Key Electronics](https://youtu.be/1nxGcfIm-TU)
- [📝 A Modern C Development Environment](https://interrupt.memfault.com/blog/a-modern-c-dev-env)

_________________

### ✳️ Software Development Life Cycle (SDLC) Models

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)
- [🔗 Wingman Software - Agility for Embedded Software Development (James Grenning)](https://wingman-sw.com/)
- [📝 An agile guide to scrum meetings](https://www.atlassian.com/agile/scrum/ceremonies)
- [📝 What is scaled agile framework? (SAFe)](https://www.atlassian.com/agile/agile-at-scale/what-is-safe)
- [🔗 Jira - Issue & Project Tracking Software](https://confluence.atlassian.com/jira)

#### 🔵 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/)

_________________

### ✳️ Version Control Systems

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)

#### 🔵 SVN (Subversion)

- [🔗 Apache® Subversion®](https://subversion.apache.org/)

_________________

### ✳️ Testing

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.

- [📝 Embedded Testing](https://artoftesting.com/embedded-testing)
- [📝 What is Embedded Testing in Software Testing?](https://www.guru99.com/embedded-software-testing.html)
- [📝 Verification vs Validation in Embedded Software](https://www.parasoft.com/blog/verification-vs-validation-in-embedded-software/)

#### 🔵 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)
- [📝 Balancing Test Coverage vs. Overhead](https://interrupt.memfault.com/blog/testing-vs-overhead)

##### 🔶 Unit Testing

- [📝 Embedded C/C++ Unit Testing Basics](https://interrupt.memfault.com/blog/unit-testing-basics)
- [📝 Embedded C/C++ Unit Testing with Mocks](https://interrupt.memfault.com/blog/unit-test-mocking)
- [🔗 Unit Testing for C (especially Embedded Software)](http://www.throwtheswitch.org/unity)
- [📝 How to Use Ceedling for Embedded Test-Driven Development](https://www.electronvector.com/how-to-use-ceedling-for-embedded-test-driven-development)
- [📘 Unit Testing Principles, Practices, and Patterns - Vladimir Khorikov](https://www.manning.com/books/unit-testing)
- [🔗 Catch2 - A modern, C++-native, test framework for unit-tests](https://github.com/catchorg/Catch2)
- [🔗 pytest-embedded](https://docs.espressif.com/projects/pytest-embedded/en/latest/)
- [📝 Introduction to testing ESP32 code with Pytest](https://blog.gistre.epita.fr/posts/brice.parent-2023-09-11-introduction_to_testing_esp32_code_with_pytest/)
- [🔗 Pigweed](https://pigweed.dev/)

###### [🔸 GoogleTest - Google Testing and Mocking Framework](https://github.com/google/googletest)

- [🔗 GoogleTest User’s Guide](https://google.github.io/googletest/)
- [🎞️ GoogleTest And GoogleMock (GTest and GMock)](https://www.youtube.com/playlist?list=PLHn7_PzMqzs5JE58kw4nWiFELEkQek5G0)

##### 🔶 Integration Testing

- [📝 Hardware CI Arena](https://electricui.com/blog/hardware-testing)
- [📝 Exclave: Hardware Testing in Mass Production, Made Easier](https://www.bunniestudios.com/blog/2018/exclave-hardware-testing-in-mass-production-made-easier)
- [📝 Regression Testing of Embedded Systems](https://www.parasoft.com/blog/regression-testing-of-embedded-systems/)

#### 🔵 CI/CD Pipelines

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)
- [📝 How to Build a Continuous Integration and Delivery Process for Embedded Software](https://medium.com/jumperiot/how-to-build-a-continuous-integration-and-delivery-flow-for-embedded-software-b0b5bf220a2)
- [📝 A guide to continuous delivery in embedded development](https://www.embedded.com/a-guide-to-continuous-delivery-in-embedded-development/)
- [🎞️ Continuous Delivery for Embedded Systems • Mike Long • GOTO 2015](https://www.youtube.com/watch?v=DcFe6cEvnGQ)
- [📝 Continuous Integration & Continuous Delivery for Embedded Systems (Whitepaper)](https://www.parasoft.com/white-paper/ci-cd-for-embedded-systems/)
- [📝 What is DevOps in an Embedded Device Company?](https://www.linkedin.com/pulse/what-devops-embedded-device-company-john-macdonald/)
- [🎞️💎 CI/CD Tutorials (YouTube Playlist)](https://www.youtube.com/playlist?list=PLy7NrYWoggjzSIlwxeBbcgfAdYoxCIrM2)

#### 🔵 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.

- [📝 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)
- [📝 Hardware-in-the-loop simulation - Wikipedia](https://en.wikipedia.org/wiki/Hardware-in-the-loop_simulation)
- [🎞️ Embedded CI/CD with HIL Testing (YouTube Playlist)](https://youtube.com/playlist?list=PL4cGeWgaBTe1uwiqIAc6fwPzPpvgPZI2J)

#### 🔵 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).

- [📝 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/)
- [🎞️ Microchip University - An Introduction To The ISA/IEC 62443 Standard](https://mu.microchip.com/an-introduction-to-the-isaiec-62443-standard)
- [🎞️ Exploring EMC Basics & Standards](https://www.youtube.com/watch?v=duhBkhlH-WY)

##### 🔶 Functional Safety

- [🎞️👶 Microchip University - Introduction to Functional Safety](https://mu.microchip.com/introduction-to-functional-safety)
- [🎞️ Udemy – Functional Safety According to ISO 26262 - Crash Course](https://www.udemy.com/course/iso-26262-crash-course/)
- [📝 A Guide to MISRA C Coding Standards - MISRA C and MISRA C++](https://www.perforce.com/resources/qac/misra-c-cpp)
- [📝 A Firmware Development Standard by Jack Ganssle](http://www.ganssle.com/fsm.htm)
- [📝 Safety-critical Embedded systems: How to prepare for software development](https://www.nagarro.com/en/blog/embedded-software-development-safety-critical-systems)
- [📝 DO-178C - Software Considerations in Airborne Systems and Equipment Certification](https://en.wikipedia.org/wiki/DO-178C)

_________________

### ✳️ 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.

- [📝 Embedded Systems Security and TrustZone](https://embeddedsecurity.io/)

#### 🔵 Hardware Hacking

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.

- [📘💎 Practical Hardware Pentesting -  Jean-Georges Valle](https://a.co/d/dq4SeNH)
- [🎞️ Hardware Hacking Tutorial (YouTube Playlist)](https://www.youtube.com/playlist?list=PLoFdAHrZtKkhcd9k8ZcR4th8Q8PNOx7iU)
- [📘💎 The Hardware Hacking Handbook: Breaking Embedded Security with Hardware Attacks - Jasper van Woudenberg, Colin O'Flynn](https://a.co/d/gUIytFX)

#### 🔵 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)
- [🎞️ Hashing, Hashing Algorithms, and Collisions - Cryptography - Practical TLS](https://youtu.be/HHQ2QP_upGM)
- [🎞️ Data Integrity - How Hashing is used to ensure data isn't modified - HMAC - Cryptography](https://www.youtube.com/watch?v=doN3lzzNEIM)
- [🎞️ Encryption - Symmetric Encryption vs Asymmetric Encryption - Cryptography - Practical TLS](https://www.youtube.com/watch?v=o_g-M7UBqI8)
- [🎞️ Public and Private Keys - Signatures & Key Exchanges - Cryptography - Practical TLS](https://youtu.be/_zyKvPvh808)
- [🎞️ Understanding AES Encryption Mechanics: BMPS](https://youtu.be/OnhtzFJW_4I)
- [📘💎 Understanding Cryptography: A Textbook for Students and Practitioners -  Christof Paar, Jan Pelzl](https://link.springer.com/book/10.1007/978-3-642-04101-3)
- [📘💎 Handbook of Applied Cryptography -  Alfred J. Menezes, Paul C. van Oorschot, Scott A. Vanstone](https://cacr.uwaterloo.ca/hac/)
- [📘 Serious Cryptography, 2nd Edition: A Practical Introduction to Modern Encryption - Jean-Philippe Aumasson](https://nostarch.com/serious-cryptography-2nd-edition)
- [🎞️ MOOC - Security Part2: Basics of cryptography (YouTube Playlist)](https://youtube.com/playlist?list=PLnMKNibPkDnFSFh57UFTZLpy-7lZiwTHh)
- [🎞️ MOOC - Security Part3 : STM32 security features (YouTube Playlist)](https://youtube.com/playlist?list=PLnMKNibPkDnFzux3PHKUEi14ftDn9Cbm7)  
- [📝 Introduction to encryption for embedded Linux developers](https://sergioprado.blog/introduction-to-encryption-for-embedded-linux-developers/)
- [📝 A hands-on approach to symmetric-key encryption](https://sergioprado.blog/a-hands-on-approach-to-symmetric-key-encryption/)
- [📝 Asymmetric-Key Encryption and Digital Signatures in Practice](https://sergioprado.blog/asymmetric-key-encryption-and-digital-signatures-in-practice/)

#### 🔵 Secure Boot & Secure Firmware Update

Make sure that only authentic, signed firmware runs and can be installed, using a hardware root of trust and verified images.

- [📝 AVR231: AES Bootloader](https://www.microchip.com/en-us/application-notes/an2462)
- [🎞️ 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)
- [🎞️ MOOC - Security Part5 : How to define your security needs (YouTube Playlist)](https://youtube.com/playlist?list=PLnMKNibPkDnGqh5OmQWw98ztpf9TeczbC)
- [🎞️ MOOC - Security Part6: STM32 security ecosystem, from theory to practice (YouTube Playlist)](https://youtube.com/playlist?list=PLnMKNibPkDnGd7J7fV7tr-4xIBwkNfD--)
- [🎞️ TPM (Trusted Platform Module) - Computerphile](https://www.youtube.com/watch?v=RW2zHvVO09g)
- [🎞️ Securing Embedded Linux Systems with TPM 2.0 - Philip Tricca, Intel](https://www.youtube.com/watch?v=0qu9R7Tlw9o)
- [📝 TPM: Basic applications to embedded devices](https://witekio.com/blog/tpm-basic-applications-to-embedded-devices/)
- [📝 OTA for Embedded Linux Devices: A practical introduction](https://interrupt.memfault.com/blog/ota-for-embedded-linux-devices)
- [📝 Introduction to Embedded Linux Security - part 1](https://sergioprado.blog/introduction-embedded-linux-security-part-1/)
- [📝 Introduction to Embedded Linux Security - part 2](https://sergioprado.blog/introduction-embedded-linux-security-part-2/)

_________________

### ✳️ Embedded GUI

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/)
- [🔗 TouchGFX](https://support.touchgfx.com/4.20/docs/introduction/welcome)
- [🎞️ Introduction to Qt / QML (YouTube Playlist)](https://www.youtube.com/playlist?list=PL6CJYn40gN6hdNC1IGQZfVI707dh9DPRc)

_________________

### ✳️ IoT (Internet of Things)

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)
- [📝 Delta Over-The-Air Device Firmware Update](https://thinkty.net/projects/2023/05/07/delta_ota.html)
- [📝 FreeRTOS Delta Over-the-Air Updates](https://www.freertos.org/Community/Blogs/2022/delta-over-the-air-updates)
- [🔗 ESP Delta OTA](https://components.espressif.com/components/espressif/esp_delta_ota)

_________________

### ✳️ 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.

- [🎞️ Intro to Edge AI: Machine Learning + IoT – Maker.io Tutorial | Digi-Key Electronics](https://www.youtube.com/watch?v=Ejld8XZmvwE)

#### 🔵 AI & ML Basics

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)
- [📝 Machine Learning Crash Course with TensorFlow APIs - Google](https://developers.google.com/machine-learning/crash-course/)

#### 🔵 TensorFlow Lite

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)
- [🎞️ TinyML: Getting Started with TensorFlow Lite for Microcontrollers | Digi-Key Electronics](https://youtu.be/gDFWCxrJruQ)
- [🎞️ TinyML: Getting Started with STM32 X-CUBE-AI | Digi-Key Electronics](https://youtu.be/crJcDqIUbP4)
- [🎞️ edX - Fundamentals of TinyML](https://www.edx.org/learn/machine-learning/harvard-university-fundamentals-of-tinyml)
- [🎞️ edX - Applications of TinyML](https://www.edx.org/learn/tinyml/harvard-university-applications-of-tinyml)
- [🎞️ edX - Deploying TinyML](https://www.edx.org/learn/tinyml/harvard-university-deploying-tinyml)
- [🎞️ edX - MLOps for Scaling TinyML](https://www.edx.org/learn/tinyml/harvard-university-mlops-for-scaling-tinyml)
- [📘 TinyML: Machine Learning with TensorFlow Lite on Arduino and Ultra-Low-Power Microcontrollers - Pete Warden, Daniel Situnayake](https://tinymlbook.com/)

_________________

### ✳️ 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 Standards](https://www.autosar.org/standards)
- [🎞️ AUTOSAR Basics | AUTOSAR Tutorial | Architecture | Automotive](https://www.youtube.com/watch?v=7b5BY1IAfwY)
- [🎞️ Introduction to AUTOSAR](https://www.youtube.com/watch?v=NfZI8wvgZPo)
- [🎞️ Udemy - Autosar Architecture (Learn from Scratch with Demo)](https://www.udemy.com/course/autosar-architecture/)
- [📝 OSEK OS Overview](https://www.autosartoday.com/posts/osek_os_overview)
- [🔗💎 OSEK/VDX Operating System Specification 2.2.3](https://www.osek-vdx.org/mirror/os223.pdf)
- [🔗💎 OSEK/VDX OIL (OSEK Implementation Language) Specification 2.4.1](https://www.osek-vdx.org/mirror/oil241.pdf)

## 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](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.

## Copyright

This work is licensed under a [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/) 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](https://www.reddit.com/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 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.