Learn IoT Programming Using Node-RED Begin to Code Full Stack IoT Apps and Edge Devices with Raspberry Pi, NodeJS, and Grafana (Bernardo Ronquillo Japón)（Z-Library）

# Learn IoT Programming Using Node-RED — Reading Guide ## 【One-Line Pitch】 A hands-on, project-driven guide for building a complete IoT system—from Raspberry Pi sensors to cloud dashboards—using Node-RED's visual programming, with a strong emphasis on simulation-first development that lets you master the software before touching hardware. Ideal for IoT engineers, embedded programmers, and hobbyists who want a low-code path to full-stack IoT applications. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces IoT architecture fundamentals—why single-board computers like Raspberry Pi are ideal IoT devices, the layered software pattern (foundation, middleware, application), and the book's project scope: temperature/humidity monitoring with time-series data. - **Early (~15%–27%)**: Sets up the software toolkit. Chapter 2 walks through Node-RED installation on Ubuntu, the web-based editor (workspace, node palette, sidebar tools), and building a first flow—a digital clock—to learn visual programming basics and package management. - **Early (~33%–39%)**: Deepens Node-RED skills with project management via Git, installing contributed packages (e.g., node-red-contrib-moment), and understanding flow JSON files. The book emphasizes simulation: you'll run the same code on a laptop that later runs on real hardware. - **Middle (~39%–52%)**: Covers the IoT edge layer—data acquisition from a virtual Sense Hat sensor (temperature, humidity, pressure, joystick events) and streaming via Pusher. You'll learn message structures, debugging, and exporting flows, all within a simulated environment. - **Late (~52%–end)**: Transitions to real hardware—setting up the physical Raspberry Pi and sensors, running unit tests, and deploying the full three-layer architecture. The final project integrates Node-RED, InfluxDB for time-series storage, and Grafana for real-time dashboards. ## 【Key Takeaways】 - **Layered architecture is the backbone of IoT design** (Early): Separating IoT foundation (sensors/streaming), middleware (data processing), and application (storage/presentation) layers makes code modular, maintainable, and extensible—adding features becomes a matter of plugging in new components. - **Simulation-first development saves time and complexity** (Early): The book's strategy of emulating Raspberry Pi and Sense Hat on a laptop lets you focus on software logic without hardware debugging. The same code transfers directly to physical devices, proving the power of well-defined software interfaces. - **Node-RED's visual editor is a full development environment** (Early): The three-region interface—workspace for wiring flows, node palette for components, and sidebar for info/debug/project tools—makes IoT logic tangible. The Debug tab is your primary tool for tracing message flow in real time. - **Flows are just JSON files** (Early): Node-RED stores everything as structured JSON, which means Git version control works naturally. Understanding this unlocks project management, collaboration, and the ability to inspect or modify flows programmatically. - **Message structure is the contract between nodes** (Middle): Every message carries topic, payload, and a unique ID. For the Sense Hat simulator, environment messages report temperature/humidity/pressure twice per second, while joystick events encode direction and press state (single, long, release)—mastering this structure is key to building reliable flows. - **Streaming APIs bridge edge and cloud** (Middle): Pusher acts as the transportation layer, moving sensor data continuously from the IoT device to remote servers. This decoupling lets you process data in real time without tight coupling between hardware and backend. - **Time-series databases and dashboards complete the stack** (Late): InfluxDB stores sensor streams efficiently for time-based queries, while Grafana provides user-friendly visualizations. Together they turn raw data into actionable environmental monitoring. ## 【Reading Tips】 - **Skim Chapter 1's conceptual sections** if you're already familiar with IoT basics; focus instead on the layered architecture diagram (Figure 1.5) which maps every chapter to a specific layer—use it as your roadmap. - **Deep-read Chapter 2's Node-RED editor tour**; the workspace/palette/sidebar workflow is foundational. Build the digital clock flow yourself rather than just reading—it teaches deployment, debugging, and package installation in one go. - **Pay special attention to the simulation setup in Chapter 3**; the Sense Hat simulator package is your gateway to understanding sensor data without hardware. Spend time inspecting debug output to internalize message formats. - **Watch for the Git integration trick** in Chapter 3's "Exporting flows" section—it solves a common pitfall when cloned projects overwrite your work. This is a practical gotcha you'll likely encounter. - **The book's examples are tested on Ubuntu 18.04** with specific Node/Python versions; if you're on a different OS, expect minor setup friction but the core concepts transfer cleanly. ## 【Coverage Limits】 This guide covers the book's first half (through ~52%), including architecture, Node-RED fundamentals, and sensor simulation. The later chapters on physical hardware setup, InfluxDB storage, and Grafana dashboards are summarized from the book's outline but not detailed from excerpts. ##