Concept Cards
Ideas above individual builds
Open the concept library to see theses, invariants, tensions, protocols, ethical boundaries and descendant prototypes.
The Resource Bank
This is everything the practice can draw from: verified physical inventory, the remaining Bill of Materials, digital tools and references, concepts and vocabulary, and the broader systems specification register. Availability and ownership remain explicit.
Bank architecture
52Verified purchase lines
0Digital resources
705System records
0Concept cards
Current inventory
Use material categories to answer a practical question: is this a durable machine, a tool, a reusable part, something that gets used up, bench infrastructure, or safety/reference material?
Digital tools and resources
Software you may install, reusable packages, GitHub repositories, datasets, research leads, inspiration and locally preserved source artifacts. “External” means available to consult—not installed or validated on your computer.
Concept bank, vocabulary and taxonomy
Concept Cards hold enduring creative grammar. Vocabulary entries explain technical terms and modalities. Taxonomy gives us a small shared language for connecting resources without forcing everything into one category.
Open concept bank →
Specification register · not a purchase claim
Attention and articulation systems
This is the seeing-and-saying layer extracted from the larger BUS / WUT register. Construction materials were excluded. Each record preserves what it is, what role it plays, how it senses or articulates, where it lives in the stack, how mature the decision is, and what owned equipment already covers it. Download the source workbook ↗
IdentityItem, form and modelRoleSense, identify, interpret, coordinate, articulate, embody or governModalityRadar, vision, EEG, projection, audio, print and moreLayerPerson, object, room, edge, core, network or outputLifecycleRequired, recommended, optional or researchConnectionsProjects, dependencies, owned coverage and acceptance tests
| System record | Role / modality | Lifecycle | Project / function | Owned coverage |
|---|
How to read this: “Required” means required by the source design logic—not necessarily that you should buy it now. “Covered” means an owned item is an exact match or already covers the equipment class. Blank coverage is an explicit reconciliation gap, not proof that nothing you own could serve the role.
How the pieces fit together
Think in layers. A system can start simple—one local sensor and one output—and progressively add richer signals without replacing the whole foundation.
1
Local nodes
ESP32-S3 or Pico reads a radar, button, load cell, tag reader, or LED strip.
ESP32-S3 or Pico reads a radar, button, load cell, tag reader, or LED strip.
2
Room coordinator
Pi 5 logs events, serves a dashboard, holds state, and coordinates modules.
Pi 5 logs events, serves a dashboard, holds state, and coordinates modules.
3
Experience output
Projectors, e-paper, light, sound, printed artifacts, or physical response.
Projectors, e-paper, light, sound, printed artifacts, or physical response.
Remaining / optional bill of materials
The things you just bought are marked covered or removed from the shopping queue. What remains is ordered by dependency, not novelty; prices are planning ranges, not live quotes.
| Recognizable name | Actual item | Why it matters | Quantity | Urgency | Planning price | Link |
|---|
Two safety rules worth memorizing: ESP32 and Pico GPIO are normally 3.3 V logic—a module accepting 5 V power does not mean its signal pins are safe at 5 V. You also now own leaded solder: label it separately, wash your hands after handling it, keep food and drink off the bench, and ventilate or extract the flux fumes.
Do not buy more of these yet
They would mostly create overlap, not new capability.
Beginner mental model
Three names that live at different layers.
Raspberry Pi is usually a small Linux computer. ESP32 is a family of microcontroller chips and boards. Arduino can mean a board company, an electronics ecosystem, an IDE, or the programming framework you can use on many boards—including your ESP32s. Understanding that naming difference removes a lot of beginner confusion.
Full computer
Raspberry Pi
Boots an operating system, runs many programs, stores files and connects to ordinary displays, USB devices and networks.
- Think of it as
- A tiny desktop or server.
- Code usually lives
- As files and services inside Raspberry Pi OS.
- Best at
- Coordination, databases, dashboards, media, networking and heavier processing.
- Weak at
- Hard real-time reactions and surviving abrupt power loss.
You own: Raspberry Pi 5, 8 GB kit with cooling, power, microSD and display cables.
Microcontroller family
ESP32
Runs one uploaded firmware program directly on the chip. It starts quickly, reads sensors and controls outputs with built-in Wi-Fi and Bluetooth.
- Think of it as
- A dedicated reflex or appliance controller.
- Code usually lives
- As firmware stored in flash memory on the board.
- Best at
- GPIO, sensor buses, local control, low cost and distributed wireless nodes.
- Weak at
- Desktop software, large files, rich video processing and general multitasking.
You own: multiple Freenove ESP32/ESP32-S3 kits, PinPulse, CrowPanel, thermal camera and integrated terminal.
Company + boards + software ecosystem
Arduino
Arduino is not one processor. It is a family of boards and a beginner-friendly software ecosystem. The Arduino IDE and programming APIs can target non-Arduino hardware.
- Think of it as
- A common way to build and upload microcontroller programs.
- Code usually lives
- In a sketch compiled into firmware.
- Best at
- Approachable examples, libraries and a large learning community.
- Important distinction
- Using Arduino IDE with an ESP32 does not turn the ESP32 into an Arduino Uno.
You own: no confirmed Arduino-branded board—and you do not need one to learn the Arduino framework on ESP32.
Where your Pico W fits: despite the Raspberry Pi brand, the Pico W is a microcontroller and belongs conceptually beside ESP32—not beside the Pi 5. It does not run Raspberry Pi OS. It is useful for MicroPython, deterministic electronics practice and simple wireless nodes.
Compare them literally
The most useful comparison is not which one is “better,” but which kind of work each machine was built to do.
| Question | Raspberry Pi 5 | ESP32 / ESP32-S3 | Typical Arduino Uno |
|---|---|---|---|
| What is it? | Single-board Linux computer | Microcontroller chip on a development board | Arduino-branded microcontroller board |
| Operating system | Yes: Raspberry Pi OS or another Linux | No desktop OS; runs firmware, often with a small real-time scheduler underneath | No desktop OS; runs one compiled sketch |
| Startup | Tens of seconds; boots from storage | Usually begins in well under a second | Usually begins almost immediately |
| Programs at once | Many processes and services | One firmware application with multiple tasks | Usually one relatively simple firmware loop |
| Common languages | Python, JavaScript, C/C++, shell and many more | C/C++ through Arduino or ESP-IDF; MicroPython also possible | C/C++ through the Arduino framework |
| Built-in networking | Wi-Fi, Bluetooth and Ethernet on Pi 5 | Wi-Fi and Bluetooth are core ESP32 strengths | Classic Uno has none without extra hardware |
| Storage | microSD, USB SSD and normal filesystems | Small flash storage; sometimes microSD on a particular board | Very small flash and EEPROM compared with Pi/ESP32 |
| Physical pins | 40-pin header; Linux controls GPIO | Board-specific GPIO with ADC, PWM and buses | Stable board pin labels and fewer resources |
| Timing behavior | Linux may pause or schedule other work | Good for fast, repeatable local control | Good for simple repeatable local control |
| Your best use | Coordinator, logger, dashboard and projector source | Radar/sensor node, local interface and physical output controller | Optional learning reference; no need to add one yet |
Where “Arduino” fits into your ESP32 work
The naming is confusing because the layers get spoken about as if they were the same thing.
Arduino IDEThe desktop application on your Mac that edits, compiles, uploads and opens Serial Monitor.
Arduino frameworkThe familiar programming model with functions such as
setup(), loop(), pinMode() and digitalWrite().ESP32 board packageEspressif’s adapter that teaches Arduino IDE how to compile for ESP32 chips and upload to their boards.
Arduino boardA physical board sold or standardized by Arduino, such as Uno or Nano. This is the part you do not currently own—and do not presently need.
The practical sentence: you can write an Arduino-style sketch in Arduino IDE, compile it with Espressif’s ESP32 board package, and upload it to a Freenove ESP32-S3 board. The software style is Arduino; the hardware remains ESP32-S3. Do not copy an Uno tutorial’s pin numbers or 5 V assumptions onto an ESP32: your ESP32 GPIO is 3.3 V and its usable pins depend on the exact board.
How they can cooperate
The Pi and ESP32 do not automatically discover each other or share pins, memory or code. You deliberately choose a communication path and define the messages.
USB serial — best first bridge
One USB data cable powers/programs the ESP32 and carries text or JSON messages to the Pi. It is visible and relatively easy to diagnose.
ESP32 sensor → USB cable → Pi Python loggerWi-Fi + HTTP — understandable web bridge
Either device can expose a small web endpoint. Useful for occasional commands, status pages and event posts.
ESP32 POST /events → Pi local web serviceWi-Fi + MQTT — best distributed bridge
The Pi can run a message broker while several ESP32 nodes publish sensor events and receive bounded commands.
radar-01 → lab/radar-01/presence → PiUART GPIO — direct embedded bridge
Two crossed data wires plus shared ground can carry serial data, but voltage, pin choice and powering must be deliberate. Learn USB serial first.
ESP TX → Pi RX · ESP RX ← Pi TX · GND ↔ GNDWhen they do not need each other
Use only the PiWhen the project is a browser dashboard, database, USB camera capture, projector display, local server or software-heavy experiment.
Use only an ESP32When one small device reads a sensor, drives LEDs or a display, exposes a basic status page, and should start immediately without Linux.
Use Pi + ESP32When physical sensing must be distributed around a room while one computer keeps history, applies rules and coordinates rich outputs.
Add Arduino hardware?Only when a specific project or shield requires it. Your current ESP32, ESP32-S3 and Pico W boards already cover beginner microcontroller learning.
A safe learning order using what you own
Keep the conceptual comparison here; use Instructionals for hands-on steps and success checks.
1 · ESP32 aloneKnown data cable → first upload → Serial Monitor → LED/button → one TinkerBlock sensor.
2 · Pi aloneImage microSD → boot → SSH → Python page → safe GPIO or projector output.
3 · Join themSend one button event over USB serial, then graduate to MQTT on your local network.
4 · Add real equipmentReplace the button with one LD2410C radar; add CrowPanel, NFC or projection only after the event path is repeatable.
RaspESP learning system
Learn each machine separately. Then make them cooperate.
A Raspberry Pi and an ESP32 are different kinds of computers. Each has physical setup, software setup and a distinct job. These guides prove each one independently before joining them into sensing, identity and room-response systems.
Change one thing at a timeKeep the last working version. Add one wire, sensor or software change, then test again.
Power off before rewiringPi and ESP32 GPIO use 3.3 V logic. Never guess about voltage, polarity or pin numbering.
Stop at the success gateYou do not need to finish every lesson. A repeatable observed result is the unit of progress.
Choose a project sprint
These are suggested routes through the same instructionals—not three more things to learn.
No paid account or cloud service is required. The complete foundation can work on your local network.
Words you will keep seeing
Open a term when instructions start sounding like another language.
Board
The physical circuit board. “ESP32-S3” names the main chip family, while Freenove or PinPulse describes a particular board built around it.
Firmware
The program uploaded into an ESP32. It starts when the board receives power and keeps running without a desktop operating system.
GPIO / pin
General-purpose electrical connection points used to read buttons and sensors or control LEDs. Pin numbers and physical positions are not interchangeable.
Ground / GND
The shared electrical reference. Two low-voltage devices usually need a common ground before their signals can be understood correctly.
Serial / UART
A simple stream of bytes. It is used for upload/debug messages and by modules such as your LD2410C radar.
I²C / SPI
Two common ways of connecting sensors and displays. I²C uses addresses; SPI uses dedicated chip-select connections.
SSH
A secure terminal connection from your main computer into the Raspberry Pi over the local network.
IP address
A device’s address on a network, such as the local address used to open your Pi or ESP32 health page.
MQTT
A lightweight message system. ESP32 nodes publish events and the Pi receives, records and reacts to them.
Personal rule: if a term blocks a step, learn only enough of that term to pass the current success gate.