The first video covered what the Wrappa system is and how setup works. This one answers the more important question: can you build something useful with it? I connected a BMP280 temperature and pressure sensor over I²C and built a live monitoring dashboard in Node-RED using the visual flow editor, with one small JavaScript modification.
Environmental monitoring is a good test case. It’s practical, uses a real sensor with a real protocol, and exercises both local dashboards and the data pipeline between module and hub. If Wrappa handles this smoothly, the concept holds up for real projects.
Hardware and wiring
The BMP280 from Bosch measures temperature and barometric pressure over I²C. Note: unlike its sibling the BME280, it does not include a humidity sensor. Temperature accuracy is ±1°C, which is adequate for home or workshop monitoring.
Total wiring: four connections. The screw terminals on the Wrappa module make this cleaner than a breadboard.
| BMP280 Pin | Wrappa Module |
|---|---|
| VCC | 3.3 V |
| GND | GND |
| SDA | D2 |
| SCL | D3 |
Starting from the Example Flow
Wrapit Solutions ships example flows inside Node-RED. Under the burger menu → Import → Examples, there’s a set of Wrapper-specific flows including one for the BME280. I used this as the base and modified it for the BMP280.
The two changes were straightforward. First, the BMP280 only exports temperature and pressure (no humidity) so the I²C read sequence needed adjusting: one read, followed by three writes, then the final read that pulls raw temperature and pressure from the sensor registers. Second, the JavaScript function node that processes the raw values needed updating to match the smaller data set coming back from the sensor.
Sensor substitution note: If you’re following along with a BME280 instead, use the original example flow unmodified and you’ll also get humidity. The BMP280 modifications here exist only because that’s what I had available.
The Rapper Manager Node
The Rapper Manager node is where you configure which physical module this flow talks to. You select the module by name (it appears once the hub has detected it), then set the I²C pin assignments. In my setup I used:
-
SCL → D3 SDA → D2
One hard constraint: you can only have one Rapper Manager node per module at a time. If you have an existing flow already managing “Wrappa 1”, you can’t add a second manager for the same module in a different flow. Plan your flows around this.
The I²C address field defaults to the BMP280’s standard address. If your sensor uses a different address (set via the SDO pin), change it here. The read and write nodes downstream are sensor-specific — what gets read and written depends entirely on the sensor’s register map, not on Wrappa itself. The same I²C node infrastructure works for other devices too, including I²C character displays.
Dashboard output
The processed data splits into two outputs: temperature and pressure, each feeding a dashboard gauge. The debug window shows the same values. Once the flow is deployed and the sensor is connected, readings appear immediately; no need for polling configuration, or driver installation.
The Node-RED flow JSON is available in the video description. Import it, update the module name and pin assignments to match your setup, and it runs.
Constraints
This demo is representative of where Wrappa works well. It’s also worth being clear about where it doesn’t.
- Pre-built nodes required You’re limited to sensors that have existing Wrapper nodes. Outside those nodes will require you writing new Node-RED nodes, which means JavaScript. That defeats the no-code premise, though the infrastructure for true no-code is there as the library grows.
- ESP8266 processing limits The module handles simple I²C reads and MQTT publishing without issue. Complex calculations or high-frequency sampling will hit its limits. Heavier processing can run on the Raspberry Pi hub instead.
- MQTT latency The communication layer adds latency that rules out real-time control, precise timing, and anything involving motor coordination. This is a fundamental constraint of the architecture, not something firmware updates will fix.
- Debugging visual flows For simple projects, Node-RED’s visual debugger is adequate. For complex flows, tracing problems through interconnected nodes is harder than reading a stack trace in code.
A note on the Poly node
The demo in this article uses Wrappa’s I²C node, which handles a specific, well-defined protocol. That’s a good fit for the BMP280. But there’s another node I haven’t covered here that’s worth flagging: the Poly node.
Where the I²C node handles one protocol, the Poly node handles almost anything else. It supports a general-purpose instruction set that lets you define read, write, and timing sequences at 10 microsecond resolution. That’s precise enough to implement 1-Wire, triggered analogue, pulse-width measurement, and UART, all from the same node type, just with different instruction strings.
As a concrete example: to read distance from an RCWL-1601 ultrasonic sensor, the Poly node receives this single instruction string:
(LA,get_proximity)(W1,10)(W0,0)(MP,2)That tells the Wrappa to pulse the trigger line for 10 µs, hold it low, then measure the duration of the echo pulse, which the downstream function node converts to a distance in centimetres. The sensor wiring, the timing, and the protocol are all expressed in that one string, with no additional driver code.
The designer has shared four working examples: DHT21, DS18B20, a dust sensor, and the RCWL-1601 above. Each demonstrates a different interface protocol, all handled by the same Poly node infrastructure.
That’s a lot of ground to cover properly. Would a dedicated post and video on the Poly node be useful to you? Let me know in the comments.
Who this is for
If you’re already comfortable with Arduino or MicroPython, Wrappa offers convenience at a price premium and some loss of flexibility. For straightforward projects the trade is reasonable; for complex or latency-sensitive ones, native development is the better fit.
If programming complexity has been the barrier between you and IoT projects, Wrappa removes it. Setup is fast, the example flows are genuinely useful starting points, and Node-RED as a platform is mature and well-supported by a large community. For home automation, workshop monitoring, greenhouse sensing, or educational use, it delivers on the promise.
Wrappa’s value is in democratising IoT development: getting people to a working system quickly, not in replacing advanced workflows. Those are different problems, and it’s the right tool for the first one.