HomeI LOVE smart home devices. Pretty much the exact moment I moved out of my parents' house to attend university, I equipped my place with a bunch of smart devices to hook into my existing Home Assistant instance. My bedroom alone has multiple smart Zigbee devices: LED bulbs and remotes, an air quality monitor, a presence/light sensor, two power switches+monitors and some other stuff I'm probably forgetting. Something about having a fully local dashboard and smart home platform around a bunch of sensors really triggers the nerd inside of me.
Now, my networking situation is a bit… interesting. Home Assistant is running on the homelab at my parents' place, but I live a little too far away for the Zigbee signal to reach all the way over here. I used to run a Raspberry Pi 4 with an SLZB-07 dongle, Zigbee2MQTT and an MQTT broker at my own place and bridged it with the broker at my homelab over a VPN. That worked incredibly well, and in fact served my needs perfectly for several years. However, the Raspberry Pi 3 in my 3D printer finally gave in recently, so I've had to salvage my only Pi 4 to fix it. That unfortunately left me with a dysfunctional Zigbee network, meaning I had to manually turn my lights on and off again (yes, by pressing buttons! Ew!)
Now imagine my excitement when the kind folks over at SMLIGHT were willing to send over one of their SMHUB devices, and all it cost was for me to write a single review about their device. Deal! That's right! I tricked you into reading a product review! Don't worry though, all the words in this post were formed from my own opinion alone, and we will still be exploring the cool software stuff behind the scenes. It's just that while working towards our remote Zigbee goal, we will also be talking about the device itself a bit, as well as what I think of it. Sounds good?
The Device
Let's first talk a bit about what this SMHUB device actually is, and how it will help us achieve our goal. In their own words:
SMHUB Nano is a professional-grade control hub running a Linux-based system that can host apps locally — Zigbee2MQTT, MQTT broker, WireGuard, Tailscale, Matterbridge, and more.
Fancy! Under the hood, the SMHUB is simply an embedded Linux device with a built-in Zigbee/Matter/Thread adapter. It doesn't have a whole lot of juice: it appears to be running on a single-core riscv CPU (bonus nerd points for ISA!) and around half a gigabyte of RAM. Despite this, it appears to be running fairly comfortably: my hub is idling at around 3% CPU usage and 300MB 'used' memory. And this is with Mosquitto, Zigbee2MQTT, Tailscale and their Python-based backend running, along with some other necessary services. You can definitely feel it drag its heels when installing apps, booting up or restarting services, but once it's up and running it's impressively smooth.
Physically, SMLIGHT appears to use the same black casing as is also used for their other Ethernet-enabled adapters. It can be powered using either a USB-C cable or PoE. PoE does indeed work quite well, and it would be great to deploy it that way; however, I only own a single PoE injector, and it's currently being used for my access point/router. So USB-C it is. Grrr. Note that no USB-C cable or power brick were provided in the box, however I think most people will likely have some of those lying around anyway. The device takes regular 5V power, so any regular old phone charger seems to work just fine. They do provide double-sided sticky pads to stick the device to a surface, as well as two mini screws + a hex key if you prefer to go that route.
The Plan
My desired end result is a device that I can simply plug into any ethernet port and which will automatically connect back to my homelab where Home Assistant runs. I already run an MQTT broker and Tailscale on my homelab, so we will be installing Tailscale on the SMHUB to add the device directly to my Tailnet, which allows it to directly communicate with my Home Assistant host. Then, we configure the MQTT broker on the SMHUB to bridge to my main 'upstream' MQTT broker. This will re-emit any messages posted on one of the two brokers on the other broker, and essentially provides a transparent bridge for MQTT messages between the two devices. Finally, we configure Zigbee2MQTT on SMHUB to connect to our local broker. Home Assistant will then be able to see all devices controlled by Zigbee2MQTT and be able to control them.
We can split this plan up into the following parts:
- Setting up SMHUB for first use
- Configuring our Home Assistant host
- Installing and configuring Tailscale on SMHUB
- Configuring Mosquitto and Zigbee2MQTT
- Adding devices to see if it works!
The Execution
Getting started
Setting up the SMHUB was quite simple. Simply plug it into power, attach an ethernet cable and you're done! The device exposes a web UI which you can reach via smhub.local. If that doesn't work, check your router for the IP address that was assigned to the device, and use that to connect to it instead.
Before configuring any settings, I would highly recommend to first update the system, apps and firmware on your device. I was running into quite a few (minor) hurdles along the way, but SMLIGHT has assured me (and I was able to verify) that the latest software versions have fixed those issues. We need to upgrade 3 different system components:
- Firmware: navigate to Settings → Updates and Restore and make sure the latest OTA update is installed. If not, click the update button and restart.
- Apps: navigate to Apps and click Refresh, then Upgrade All. Alternatively, open a terminal from the Console menu and run:
sudo opkg update && sudo opkg upgrade - Adapter Firmware: navigate to Settings → Radios, select a radio mode (Zigbee Coordinator), then select the newest firmware and click Update.
Configuring Home Assistant
There are many ways to install and use Home Assistant, and configuration will depend on how you have your smart home set up. If you are using Home Assistant OS, here are some pointers:
- Mosquitto add-on: https://github.com/home-assistant/addons/blob/master/mosquitto/DOCS.md
- Tailscale add-on: https://github.com/hassio-addons/addon-tailscale/blob/main/tailscale/DOCS.md
What matters is that you have an MQTT broker running with Home Assistant connected to it, and that the broker is reachable through Tailscale.
Running Tailscale on SMHUB
Tip: At the time of writing, SMHUB does not officially support Tailscale yet. We will therefore be installing it manually for now. SMLIGHT has indicated they intend on providing Tailscale support soon.
Currently, Tailscale is not yet officially supported on the SMHUB. However, the binaries published by Tailscale work quite well and can be installed relatively easily. Run the following commands from the Console tab to download, extract and install Tailscale 1.92.1 to /opt/bin/:
wget https://pkgs.tailscale.com/stable/tailscale_1.92.1_riscv64.tgz
tar -xvf tailscale_1.92.1_riscv64.tgz
sudo mv tailscale_1.92.1_riscv64/tailscale tailscale_1.92.1_riscv64/tailscaled /opt/bin/
rm -rf tailscale_1.92.1_riscv64*This works, but requires us to manually start the Tailscale daemon every time. Let's create an init.d script to automatically run it at boot:
sudo nano /etc/init.d/S98tailscalePaste the following contents:
#!/bin/sh
DAEMON="tailscaled"
PIDFILE="/var/run/$DAEMON.pid"
LOGFILE="/var/log/$DAEMON.log"
export PATH=/opt/bin:$PATH
start() {
printf "Starting tailscale: "
mkdir -p /run/tailscale /var/lib/tailscale
start-stop-daemon --start --background --make-pidfile \
--pidfile "$PIDFILE" \
-o -O "$LOGFILE" \
--exec /opt/bin/tailscaled -- \
--state=/var/lib/tailscale/tailscaled.state \
--socket=/run/tailscale/tailscaled.sock
status=$?
[ "$status" -eq 0 ] && echo "OK" || echo "FAIL"
return "$status"
}
stop() {
printf "Stopping tailscale: "
start-stop-daemon --stop --quiet --pidfile "$PIDFILE" --exec /opt/bin/tailscaled
/opt/bin/tailscaled --cleanup > /dev/null 2>&1
rm -f "$PIDFILE"
}
case "$1" in
start|stop|restart) "$1" ;;
reload) restart ;;
*) echo "Usage: $0 {start|stop|restart}"; exit 1 ;;
esacExit nano using Ctrl+X. Now start the daemon and sign in:
sudo chmod 755 /etc/init.d/S98tailscale
sudo /etc/init.d/S98tailscale start
sudo /opt/bin/tailscale upIf all went well, your SMHUB should now be added to your Tailnet! Reboot once to confirm Tailscale starts automatically.
Configuring Mosquitto & Zigbee2MQTT
Warning: We will not be configuring a username/password for our MQTT broker in this tutorial. If you intend on deploying SMHUB in an untrusted environment, make sure to set one up.
Both Mosquitto and Zigbee2MQTT can be configured from the web UI alone. Navigate to Apps → MQTT and set:
- Allow Anonymous: enable if you don't have username/password configured
- Enable bridge mode: enabled
- Remote Address: address of your MQTT broker connected to Home Assistant — e.g.
hass:1883(device name via Tailscale + default MQTT port) - Remote User/Password: credentials for your existing MQTT broker (if required)
- Bridge Topic:
# both 0to bridge messages in both directions
Save your settings. The MQTT server will reload automatically.
To configure Zigbee2MQTT, navigate to Apps → zigbee2mqtt and set:
- Start at Boot: enabled
- Serial Port:
/dev/ttyS1 - Baud Rate:
115200 - Adapter:
Ember - Zigbee Channel: leave default unless you're having interference issues
- MQTT Broker URL:
mqtt://localhost:1883(default) - Home Assistant: enabled
Click Stop then Run to restart Zigbee2MQTT. This can take a minute.
Adding Devices
If all went well, Zigbee2MQTT on your SMHUB should now be attached to your Home Assistant instance! Navigate to Zigbee2MQTT in the web UI to see your shiny new instance. If something doesn't work, click View Logs to see what went wrong.
To add devices, click Permit Join and follow your device's specific instructions. The Z2M device database is a great resource to find instructions for your device.
And that's it! You now have a fully functional, fully portable Zigbee coordinator that can be deployed anywhere in the world.
Results
I've been running the above configuration for several days now with ~7 Zigbee devices, and it's been rock solid so far. One thing that really stood out to me was how low the latency is. Toggling devices on and off feels practically instant — despite the fact that the command makes an entire round trip: from here to the Home Assistant server at my parent's place, then back across two MQTT brokers and Zigbee2MQTT. My previous setup with a Raspberry Pi was practically the same, and even though the Pi is a lot more powerful than the SMHUB, the lack of compute power does not appear to significantly impact network performance in any way.
Conclusion
The Good
- Very nice / responsive web UI
- Surprisingly stable
- Flexible power and mounting options (USB-C or PoE)
- Easy to set up
- Full root device access for power users
SMHUB seems to break with the tradition of products targeting only one type of user. The out-of-the-box experience is great: setup is easy, pretty much everything you need is configurable through the web UI and overall it just works. But at the same time, the device was also designed with power users in mind. You get full root access, and since the web UI populates its config values from the actual device state, changes made through the console are reflected in the web UI and vice versa. A remarkably good balance between ease of use and flexibility.
The Ehhhhhh
- Performance is barely enough
- Not technically open source
- Some features are currently missing
While the compute resources are good enough to run the built-in apps, performance is tight. Updating apps can take a while, the device takes a few minutes to fully boot, and downloading files over HTTPS is capped at ~20 Mbps due to the slow CPU. Once your apps are up and running though, it's surprisingly smooth.
The SMHUB's firmware is not technically open source. SMLIGHT boasts about "Linux inside" but doesn't say anything about the firmware itself. That said, it is easy to get root access, and the smhub_backend Python library is completely unobfuscated — transparent enough to audit and verify it isn't doing anything unexpected.
The Bad
- Emergency flashing only supported on Windows
- Difficult to lock down in untrusted networks
If your device is bricked, the emergency flashing script is currently only supported on Windows — Linux and MacOS users are out of luck. And by default, the MQTT server and other services are reachable externally, with SSH root login enabled. If deploying in an untrusted environment, definitely put the device on a separate LAN segment.
Final Words
So, am I happy with the final result? Yes! Very much so. It's a pretty good successor to my previous Raspberry Pi setup. It's really nice to have a simple device that manages my Zigbee network and simply exposes an MQTT broker, while simultaneously tying in with my Tailscale network.
Would I recommend it to others? Depending on your use case: yes, absolutely. For ~€45 you get everything you need in a single device that's also very easy to set up. If you need Zigbee coverage in a different location or even on the other side of your house, this device will work great. That's a pretty good deal.