A Greenhouse Left To Grow Naturally

It's 2 AM. The temperature in the greenhouse drops below the threshold. A soil moisture sensor flags that the irrigation cycle didn't complete. A relay clicks. A pump kicks on. Forty minutes later the cycle finishes, the relay drops, and the node logs the event.

Nobody woke up. Nobody checked a dashboard. Nobody's server was involved.

That's the goal of IoThome, not a smarter app, not a prettier dashboard, but a node that handles its own business without asking permission from the internet.

Here's how it actually works.

The Hardware Problem Nobody Talks About

Smart farming IoT demos are easy. Stick a soil moisture sensor on an Arduino, hook up a relay module, write 50 lines of code, and you've got something that works on your desk. Getting that same thing running reliably in a field, unattended, for six months, is a completely different problem.

The hardware that gets you to a demo almost never survives contact with a real deployment. GPIO pinouts vary between boards. Analog sensing requires clean signal conditioning. Relay outputs need proper isolation. And if you're running multiple sensors and actuators on a single node, you run out of GPIO fast.

The typical answer is to redesign the hardware from scratch. New PCB, new firmware, new everything. That's expensive, slow, and means your prototype work was largely throwaway.

IoThome was built specifically to eliminate that cycle. At its core is the IoTextra module family, standardised, open hardware I/O mezzanines that sit on top of smart compute modules. The smart compute module changes depending on your needs, but the I/O hardware stays consistent, the wiring stays consistent, and the software stays consistent. You prototype with the same hardware you deploy. That single decision saves weeks.

The IoThome Stack

IoThome is three layers that each do one job well, and the key is how tightly they fit together.

Layer 1: IoTextra I/O Modules

IoTextra is the physical backbone of every IoThome node. These are purpose-built professional I/O hardware modules designed from the ground up for real deployments. IoTextra solves the typical maker problem: prototypes work on breadboards but aren't reliable for 24/7 operation. These modules provide industrial-grade signal conditioning with maker-friendly interfaces.

IoTextra comes in three key variants:

These modules communicate via I²C or GPIO and have connectors or screw terminals for field wiring, no breadboard rats' nests, no hand-soldering GPIO protection circuits. The analog inputs have proper signal conditioning, which matters when you're reading sensors in electrically noisy environments.

Make Things Happy provides two key controller options for running IoThome:

IoTsmart is the rapid prototyping path, compact System-on-Module (SOM) boards based on ESP32-S3, RP2040, RP2350A, and other MCUs that plug directly into IoTextra modules. These are designed for IoT-based distributed sensing and control. Think of IoTsmart as the "Arduino phase" of a project, except you don't throw it away later, it's production-ready for many applications, especially wireless sensor networks and low-channel-count industrial automation.

IoTbase is the more robust controller platform with better thermal management, more mounting options, and serial debugging capability during operation. You'd migrate to IoTbase when you need more I/O expansion, professional enclosure mounting, or are deploying in harsher environments.

For a smart farming node you're typically working with the IoTextra Combo and an IoTbase NANO, the workhorse of the family. It puts both analog inputs and digital outputs on a single board, which is exactly what you need when you're reading soil sensors and driving irrigation relays from the same node.

The analog side gives you two differential input channels with 16-bit resolution and a programmable gain amplifier. That's enough dynamic range to handle low-voltage sensor outputs and 4–20 mA industrial current loops, soil moisture, tank levels, flow meters, temperature transmitters, whatever the application demands.

The digital side gives you two I/O lines over I²C or GPIO. Configured as outputs, these drive relay coils or SSR control inputs. 

Both sides talk I²C, keeping the wiring between compute module and mezzanine to four wires regardless of how many channels you're using. That matters when you're building something that needs to stay reliable over months of vibration, temperature cycling, and the occasional aggressive maintenance session.

Layer 2: Tasmota as the Firmware Base

IoThome runs on top of Tasmota, a mature, open-source ESP32 firmware that handles WiFi, MQTT, OTA updates, and a built-in web UI out of the box. The reason IoThome chose Tasmota as its base isn't just convenience. It's a deliberate architectural decision.

Tasmota has been battle-tested across millions of devices. Its connectivity stack is solid. Its OTA update mechanism works. Its Berry scripting engine, a lightweight scripting language running directly on the ESP32, gives IoThome a stable, maintainable surface for automation logic without touching the firmware itself.

This matters enormously for long-term deployments. IoThome leverages Tasmota so that you inherit years of community hardening without maintaining a custom firmware fork. Tasmota handles the infrastructure. IoThome handles the application.

Layer 3: IoThome Automation Logic

This is where IoThome earns its place. The automation layer is what transforms a generic ESP32 running Tasmota into a purpose-built field node. It reads the physical world through analog inputs, makes decisions, and drives digital outputs, all on-device, on a timer, with no external system in the loop.

A smart farming irrigation node, for example, reads soil moisture on a configured interval. When moisture drops below threshold it opens the valve relay, runs the irrigation cycle, closes the relay, and logs the event. If moisture is still low after the cycle it waits and tries again. All of this runs on the node itself. The network is used for telemetry and remote management, not for the primary control loop. If the broker goes down, the irrigation keeps running.

That's the design principle IoThome is built around: local-first, autonomous operation with connectivity as a feature, not a dependency.

Putting It Together: A Real Field Node

A complete irrigation control node pairs an IoTbase NANO or IoTsmart compute module with the IoTextra Combo mezzanine. The Combo sits directly on top, giving you analog inputs and digital outputs in a compact, consistent footprint that fits inside a standard weatherproof enclosure with just a power supply and sensor cables breaking out.

Soil moisture sensors wire to the analog inputs. Relay coils wire to the digital outputs. The relays control solenoid valves on the irrigation lines.

Setup is deliberately fast. Flash Tasmota, apply the IoThome configuration template for your module combination, drop in the automation logic, set your thresholds, and reboot. The node comes up running. From that point it operates autonomously, reading sensors, making decisions, firing outputs, logging state, without any further intervention required.

When the network is up, MQTT publishes sensor readings and relay states automatically. This plugs directly into Home Assistant, Node-RED, Grafana, or any MQTT-capable system without additional middleware. You can build dashboards, write cross-node automations, and log historical data. But none of that is required for the node to function.

What IoThome Actually Solves

ESP32 exists. Tasmota exists. I²C ADCs and GPIO expanders are commodity parts. Anyone can wire these together. The reason IoThome matters is that it makes the whole thing coherent.

IoTextra gives you standardized hardware with a consistent interface across every node in your deployment. IoThome gives you the automation layer that runs on top of it, tested, documented, and easy to update in the field over WiFi. The integration between hardware, firmware, and application logic is designed and maintained as a single system, not assembled from whatever happened to work last week.

Most importantly: the hardware you prototype with is the hardware you deploy. When something needs to change, and it always does, you push a software update over WiFi, not a PCB revision.

For anyone who has been through the prototype-to-production grind, whether at home or in a commercial context, that's the part worth paying attention to.

Because at the end of the day, the best IoT node is the one that just works, whether the internet does or not.

Build Your Professional Automation Network

All modules used in this project are part of the IoThome series. You can find individual boards, sensors, and full kits at makethingshappy.io. If you're looking for reliable, modular hardware for your next industrial IoT project, the MakeThingsHappy ecosystem is built for you. 

📦 Explore the full IoThome ecosystem: github.com/makethingshappy/iothome

🛒 Buy IoThome Hardware (Official Store): makethingshappy.io