Real-Time Embedded Systems with Open-Source Operating Systems (Bertolotti, Ivan Cibrario Manduchi etc.)（Z-Library）

【One-Line Pitch】 A hands-on guide that connects real-time scheduling theory to actual code on Linux and FreeRTOS, using three progressively harder case studies on cheap, widely available hardware. Best for embedded developers and students who want to understand *why* an RTOS helps before committing to one. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's three intertwined topics—embedded systems, real-time systems, and open-source operating systems—and states the core premise: theory only becomes useful when implemented on real systems. Introduces the case-study-first approach. - **Early (~10%–30%)**: Builds concurrent-programming fundamentals through a vision-control case study, then covers I/O, DMA, threads vs. processes, synchronization primitives (mutexes, semaphores, message queues), and network communication across Linux and FreeRTOS. - **Middle (~30%–55%)**: Shifts to real-time scheduling theory—cyclic executives, rate-monotonic and EDF scheduling, utilization- and response-time-based schedulability analysis, priority inversion, and self-suspension. - **Late (~55%–80%)**: Applies theory through three case studies of increasing complexity: a general-purpose IoT/embedded controller, real-time high-performance data acquisition with an FPGA and Linux driver, and control-theory/DSP examples. - **Ending (~80%–100%)**: Consolidates with exercises and solutions throughout, plus a companion GitHub repository providing all source code and installation guides to replicate the case studies. 【Key Takeaways】 - **Theory and practice are deliberately interleaved** (Middle): scheduling formalism is presented *after* concurrency concepts, so the math maps onto real code rather than floating abstractly. - **Linux and FreeRTOS represent opposite extremes** (Middle): Linux is a full OS moving toward real-time responsiveness; FreeRTOS is a minimal-footprint system for microcontrollers—studying both shows the design space. - **A case study opens the book, not closes it** (Middle): the early vision-control example doubles as a prerequisite refresher on computer architecture (I/O, memory management, context switching). - **Schedulability analysis is treated rigorously but accessibly** (Early–Middle): rate-monotonic, EDF, utilization bounds, and response-time analysis are covered with proofs that can be skipped without losing the conceptual thread. - **Priority inversion and blocking are first-class concerns** (Middle): priority inheritance and priority ceiling protocols are analyzed alongside their schedulability implications. - **Three case studies scale in difficulty** (Late): the first runs on an ordinary PC; the others use low-cost open-source hardware (including RedPitaya STEMlab 125-14) with freely downloadable code. - **Self-assessment is built in** (Throughout): exercises and solutions accompany each chapter, and the GitHub repository supports replication and further experimentation. - **The goal is decision support, not dogma** (Opening): readers should finish able to judge whether an RTOS is worth adopting over traditional techniques for their next project. 【Reading Tips】 - **Skim the opening case study if you already know computer architecture**—it exists to level the playing field, not to teach new material to experienced readers. - **Deep-read the scheduling chapters (Middle)** if real-time guarantees matter to your work; the proofs are optional but the analysis methods are the book's core intellectual contribution. - **Work the exercises before moving on**—the book is designed for self-paced learning, and the solutions let you verify understanding without an instructor. - **Clone the GitHub repository early** and run the case studies as you read; the authors stress that concepts only stick when you write, debug, and run the code. - **Pair Linux and FreeRTOS chapters** to see how the same concurrency primitives differ across a full OS and a minimal kernel. 【Coverage Limits】 The excerpts cover the book's structure, preface, and table of contents in detail but do not include the actual technical content of most chapters; specific code examples, mathematical derivations, and case-study implementation details are not available for synthesis here.