Programming with MicroPython Embedded Programming with Microcontrollers and Python (Nicholas H. Tollervey)（Z-Library）

【One-Line Pitch】 A hands-on guide to running Python 3 on tiny, cheap microcontrollers, taking you from your first blinking LED to networked, musical, and robotic projects. Best for Python programmers, educators, and makers who want to bring their code into the physical world without learning C. 【Book Arc】 - **Opening (~0%–13%)**: Frames what MicroPython is—a lean reimplementation of Python 3 for embedded systems—and why it matters, while laying out the book's roadmap and the four target boards (PyBoard, micro:bit, Circuit Playground Express, ESP8266/ESP32). - **Early (~13%–30%)**: Gets you set up on each board: hardware capabilities, flashing firmware, connecting to the REPL, and the milestone of making an LED blink—the proof that your whole toolchain works. - **Early–Middle (~30%–40%)**: Introduces a framework for thinking about embedded projects (drawing on David Rose's ideas about "enchanted" objects) and walks through board-specific tooling like the micro:bit's browser editor and the Mu editor. - **Middle (~40%–55%)**: Explores the hardware itself—sensors, buttons, NeoPixels, speakers, accelerometers—showing how each board senses and acts on its environment. - **Late (~55%–85%)**: A series of practical example chapters covering visual feedback, input and sensing, GPIO, networking, sound and music, and robotics, all written to be extended into your own projects. - **Ending (~85%–100%)**: Covers idiomatic MicroPython under tight memory and performance constraints (including handling memory errors), then points you toward next steps and the wider Python community. 【Key Takeaways】 - **MicroPython is Python 3, trimmed for microcontrollers** (Early): You keep object orientation (minus metaclasses), core data types and structures, first-class functions, exceptions, generators, comprehensions, and even async/await—so existing Python skills transfer directly. - **Feature availability varies by board** (Early): Modules are ported selectively; the micro:bit ships a cut-down `random`, the ESP8266 uses minimalist `urandom`, and WiFi boards add `json` and `urequests`. Always check what your specific port actually provides. - **"If you can blink an LED, the essentials are in place"** (Early): The book treats a working blink as the gateway milestone—once firmware, code upload, and REPL access all function, everything else is extension. - **Four boards anchor the whole book** (Early–Middle): PyBoard (most powerful, STM32 with floating point), micro:bit (education-focused), Circuit Playground Express (rich onboard sensors and NeoPixels), and ESP8266/ESP32 (WiFi-capable). - **Embedded devices become "enchanted" objects** (Early): Small enough to be sewn, soldered, or screwed onto everyday things, they turn ordinary objects into programmable ones—the book's motivating frame for why this matters. - **Tooling choice affects the learning curve** (Middle): Browser-based flashing for the micro:bit works but was found clunky in testing; Mu offers a friendlier cross-platform editor with direct REPL connection and simple file transfer. - **Constrained environments demand idiomatic code** (Late): Memory errors and performance limits are normal here, and the book dedicates a chapter to squeezing the most out of the microcontroller. - **Community is part of the path forward** (Ending): The conclusion directs readers toward contributing to and joining the MicroPython community as the natural next step. 【Reading Tips】 - **Skim the board-setup chapters for your board only.** If you already own a micro:bit or ESP32, deep-read that section and treat the others as reference—the blink milestone is the same everywhere. - **Deep-read the idiomatic MicroPython chapter even if you're experienced.** Memory management and performance tuning are where embedded Python differs most sharply from desktop Python. - **Treat the example chapters as launchpads, not recipes.** The author explicitly wrote them to be extended; type them in and then modify them rather than copying verbatim. - **Keep the module-availability caveat in mind constantly.** When something doesn't work, check whether your port implements it before debugging your own code. - **Don't skip the project-thinking framework.** It's easy to dismiss as philosophy, but it's the book's tool for turning toy examples into projects that solve real problems. 【Coverage Limits】 These excerpts cover the book's structure, rationale, board overviews, and tooling, but do not include the actual code walkthroughs from the visual feedback, networking, sound, or robotics chapters, nor the detailed contents of the idiomatic MicroPython chapter.