r/ZigBee

I'm still fairly new to Home Assistant, so apologies if this is a basic question.

I'm currently running Home Assistant in Docker on Ubuntu 26.04, and I'm at the stage where I want to start adding Zigbee sensors around the house. In the future I'd also like to get into Thread/Matter devices, but that's not an immediate priority.

I've been looking at the SONOFF Dongle Max (Dongle-M) as a Zigbee coordinator for Zigbee2MQTT, but I honestly haven't been able to find many genuine opinions or detailed reviews on it. Most of the YouTube videos I've come across feel sponsored or are just product overviews without much real-world experience.

For those of you using Zigbee2MQTT, how has the Dongle-M been? Would you recommend it?

One thing I'm a little confused about is its Zigbee + Thread support. From what I understand, it can be used for both, but does that mean it's trying to run Zigbee and Thread simultaneously on the same radio using Silicon Labs' multiprotocol setup (which I've read hasn't always had the best reputation)? Or are they effectively separate implementations where you're not dealing with the old unreliable multiprotocol issues?

If I eventually want both Zigbee and Thread in my Home Assistant setup, would you trust the Dongle-M, or would you still recommend sticking with something more established like an SMLight SLZB coordinator?

Speaking of SMLight, I'm also a bit lost because there seem to be quite a few SLZB models now. I noticed one with dual antennas that also mentions Zigbee and Thread support. Is that essentially the same idea as the SONOFF Dongle-M, or is it implemented differently?

I'd really appreciate hearing from people who have actually used these coordinators long-term. Reliability is much more important to me than having the latest features.

Thanks in advance!

Bought a slzb06m running zha now I’m going the zigbee2mtqq route. Should I get the slzb06 now? Since it’s made for zigbee2mtqq because of the chipset

What works best / is most reliable. Moes, Zemismart, LifeLibero is what I could find on aliexpress. It needs to be rechargeable with usb C and compatible with Z2MQTT. Only integrated into the tube one´s. No chain drive.

Hi everyone,

I’m working on upgrading a lighting circuit in my house and I could really use a quick sanity check on my wiring diagram before stuffing everything back into the junction box.

My Goal: I want to control a pair of light bulbs using both my smartphone/Alexa and my existing physical wall switches. Crucially, I only care about dimming via the app or voice control. From the physical wall switches, I just want a standard, reliable ON/OFF toggle action.

The Problem & Constraints: The current setup is a traditional multi-switch circuit with two 3-way switches (deviatori) and one 4-way switch (invertitore). I absolutely cannot pull any new wires through the existing conduits.

Initially, I tried running the 230V switched phase straight into the S2 terminal while leaving S1 empty—which surprisingly works on standard, non-dimmable Sonoff Mini switches. However, on this dimmer model, it causes the light to stay stuck at 100% brightness and ignores all inputs. The S1/S2 ports on this dimmer are meant for dry contacts only and hate external 230V voltage.

The Solution & Parts Purchased: To bypass this without routing new cables, I bought these exact parts:

• Sonoff MINI Zigbee Dimmer (MINI-ZBDIM)
• Finder 13.31 Monostable Relay (230V AC coil)

My plan is to use the Finder 13.31 as an isolation interface (galvanic isolation). The 230V switched phase coming from the last wall switch will power the Finder's coil (A1), with Neutral going to A2. Then, the completely isolated dry contact terminals from the Finder (11 and 14) will connect straight into S1 and S2 on the Sonoff Dimmer.

I intend to set the external switch type to "Edge" (or Toggle) in the eWeLink app, so that any flip of a wall switch toggles the light state.

https://preview.redd.it/0t3si3lxg6ah1.png?width=896&format=png&auto=webp&s=e6f9689694e10af0e4f993d24989be47a1e83ed1

Does this configuration look solid and safe to you? Will the Sonoff Dimmer properly handle the open/closed states from a monostable relay when configured in Edge mode?

Thanks in advance for your insights!

I've had a few post here regarding converting some Lumary 6in Slim ceiling lights that originally came with WB2L Tuya chips, that I then chip swapped them with ESP-C05 chips to move them to ESPHome, and now want to move over to Zigbee. Without an identical pinout option on the market I'm using the ESP32-C6 chips wired in.

https://preview.redd.it/8t0bkap9259h1.png?width=1920&format=png&auto=webp&s=711a28ae5bd94cc9f7cf1fd67084f00c9843c16c

I want to share what I have that seems to be working really well now. I had some issue with RGB color mixing, but after adding the gamma curve adjustment the colors are much better. While I left it in the code commented out I didn't care for the gamma adjustment when it came to the white lights so I switched that back to a linear mix. I'd say that it's as good or maybe better than the color mix of ledc in ESPHome, at least for these specific lights.

Anyways, why I called this the prime day update is there is a deal going for the ESP32-C6 chips. Unfortunately they are limiting to one per customer, but thanks to some friends & family members, and being happy enough with my below Arduino code I pulled the trigger and plan to chip swap (Again) all 24 of my light and get them off of Wi-Fi.

I hope my code here (yeah I should probably put it on github) is helpful to others. I hadn't worked with Arduino code before this and I wasn't able to find any direct examples for RGBWW lights like what I was after.

// Check for the Coordinator/Router compiler flag instead of End Device
#ifndef ZIGBEE_MODE_ZCZR
#error "Zigbee Coordinator/Router mode is not selected in Tools->Zigbee mode"
#endif

#include "Zigbee.h"

// Define the GPIO pins for your MOSFETs/drivers ruling the LED strips
#define PIN_RED    19   // D8
#define PIN_GREEN  20   // D9
#define PIN_BLUE   17   // D7
#define PIN_WARM   23   // D5
#define PIN_COLD   16   // D6

#define ZIGBEE_ENDPOINT 10

// LEDC PWM Setup
#define PWM_FREQ        20000
#define PWM_RESOLUTION  10 // 10-bit resolution = maximum PWM value is 1023

// Global Light Variables
bool current_state = false;
uint8_t current_level = 255;
uint8_t color_r = 255, color_g = 255, color_b = 255;
uint16_t color_temp = 250; // Mireds
uint8_t color_mode = 0;    // 0 = RGB, 1 = Color Temperature
uint16_t min_mireds = 154;  // mireds ~ 1000000 / 6500
uint16_t max_mireds = 370;  // mireds ~ 1000000 / 2700

// Instantiate the endpoint
ZigbeeColorDimmableLight zbLight = ZigbeeColorDimmableLight(ZIGBEE_ENDPOINT);

// 10-bit Gamma Correction Lookup Table (Gamma = 2.2)
// Maps linear 8-bit inputs (0-255) to human-perceived 10-bit PWM outputs (0-1023)
const uint16_t gammaTable[256] PROGMEM = {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
  2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 7, 8, 9, 10, 11,
  12, 13, 14, 15, 16, 18, 19, 20, 22, 23, 25, 27, 28, 30, 32, 34,
  36, 38, 40, 43, 45, 47, 50, 52, 55, 58, 60, 63, 66, 69, 72, 75,
  79, 82, 85, 89, 93, 96, 100, 104, 108, 112, 116, 121, 125, 129, 134, 139,
  143, 148, 153, 158, 163, 169, 174, 179, 185, 191, 196, 202, 208, 214, 220, 226,
  233, 239, 246, 253, 259, 266, 273, 280, 288, 295, 303, 310, 318, 326, 334, 342,
  350, 359, 367, 376, 385, 394, 403, 412, 421, 431, 440, 450, 460, 470, 480, 490,
  501, 512, 522, 533, 544, 555, 566, 578, 589, 601, 612, 624, 636, 648, 660, 673,
  685, 698, 711, 724, 737, 750, 763, 777, 790, 804, 818, 832, 846, 861, 875, 890,
  905, 920, 935, 950, 966, 981, 997, 1013, 1029, 1045, 1062, 1078, 1095, 1112, 1129, 1146,
  1163, 1180, 1198, 1216, 1234, 1252, 1270, 1288, 1307, 1325, 1344, 1363, 1382, 1401, 1421, 1440,
  1460, 1480, 1500, 1520, 1541, 1561, 1582, 1603, 1624, 1645, 1666, 1688, 1709, 1731, 1753, 1775,
  1797, 1819, 1842, 1864, 1887, 1910, 1933, 1956, 1979, 2003, 2026, 2050, 2074, 2098, 2122, 2146,
  2171, 2195, 2220, 2245, 2270, 2296, 2321, 2347, 2373, 2399, 2425, 2451, 2478, 2504, 2531, 2558,
  2585, 2612, 2640, 2667, 2695, 2723, 2751, 2779, 2807, 2836, 2865, 2894, 2923, 2952, 2981, 3011
};

void update_hardware_leds()
{
  if (!current_state)
  {
    ledcWrite(PIN_RED, 0);
    ledcWrite(PIN_GREEN, 0);
    ledcWrite(PIN_BLUE, 0);
    ledcWrite(PIN_COLD, 0);
    ledcWrite(PIN_WARM, 0);
    return;
  }

  float dim_factor = current_level / 255.0;

  if (color_mode == 0)
  { // RGB Mode
    // 1. Calculate uncorrected, scaled 8-bit color values
    uint8_t r_lin = (uint8_t)(color_r * dim_factor);
    uint8_t g_lin = (uint8_t)(color_g * dim_factor);
    uint8_t b_lin = (uint8_t)(color_b * dim_factor);

    // 2. Fetch gamma-corrected 10-bit properties (scaled down from 12-bit array map via >> 2)
    ledcWrite(PIN_RED,   pgm_read_word(&gammaTable[r_lin]) >> 2);
    ledcWrite(PIN_GREEN, pgm_read_word(&gammaTable[g_lin]) >> 2);
    ledcWrite(PIN_BLUE,  pgm_read_word(&gammaTable[b_lin]) >> 2);
    ledcWrite(PIN_COLD,  0);
    ledcWrite(PIN_WARM,  0);
  } 
  else 
  { // White Spectrum Mode
    // 1. Map color temperature variables linearly to standard 8-bit format
    uint8_t warm_lin = map(color_temp, min_mireds, max_mireds, 0, 255);
    uint8_t cold_lin = 255 - warm_lin;

    // 2. Incorporate master dimming levels into 8-bit tracking variables
    warm_lin = (uint8_t)(warm_lin * dim_factor);
    cold_lin = (uint8_t)(cold_lin * dim_factor);

    // 3. Process outputs using gamma-corrected curves, shifting values to 10-bit PWM range
    ledcWrite(PIN_RED,   0);
    ledcWrite(PIN_GREEN, 0);
    ledcWrite(PIN_BLUE,  0);
-
    //With Gamma Correction:
    //ledcWrite(PIN_COLD,  pgm_read_word(&gammaTable[cold_lin]) >> 2);
    //ledcWrite(PIN_WARM,  pgm_read_word(&gammaTable[warm_lin]) >> 2);


    //Without Gamme Correction:
    ledcWrite(PIN_COLD,  (uint16_t)(cold_lin * 4));
    ledcWrite(PIN_WARM,  (uint16_t)(warm_lin * 4));
  }
}

void setRGBLight(bool state, uint8_t r, uint8_t g, uint8_t b, uint8_t level)
{
  current_state = state;
  current_level = level;
  color_r = r;
  color_g = g;
  color_b = b;
  color_mode = 0; // Toggle to RGB Mode
  
  Serial.printf("RGB -> State:%d, Level:%d, R:%d G:%d B:%d\n", state, level, r, g, b);
  update_hardware_leds();
}

void setTempLight(bool state, uint8_t level, uint16_t mireds)
{
  current_state = state;
  current_level = level;
  color_temp = mireds;
  color_mode = 1; // Toggle to White Temp Mode
  
  Serial.printf("Temp -> State:%d, Level:%d, Mireds:%d\n", state, level, mireds);
  update_hardware_leds();
}

void setup()
{
  Serial.begin(115200);

  ledcAttach(PIN_RED,   PWM_FREQ, PWM_RESOLUTION);
  ledcAttach(PIN_GREEN, PWM_FREQ, PWM_RESOLUTION);
  ledcAttach(PIN_BLUE,  PWM_FREQ, PWM_RESOLUTION);
  ledcAttach(PIN_COLD,  PWM_FREQ, PWM_RESOLUTION);
  ledcAttach(PIN_WARM,  PWM_FREQ, PWM_RESOLUTION);

  // Enable XY (RGB) and Color Temperature capabilities
  zbLight.setLightColorCapabilities(ZIGBEE_COLOR_CAPABILITY_X_Y | ZIGBEE_COLOR_CAPABILITY_COLOR_TEMP);

  zbLight.setManufacturerAndModel("Lumary", "6in Slim Light");
  
  // Bind callbacks
  zbLight.onLightChangeRgb(setRGBLight);
  zbLight.onLightChangeTemp(setTempLight);

  zbLight.setLightColorTemperatureRange(min_mireds, max_mireds);

  Zigbee.addEndpoint(&zbLight);

  Serial.println("Starting Zigbee Subsystem...");
  if (!Zigbee.begin(ZIGBEE_ROUTER))
  {
    Serial.println("Failed to start! Rebooting...");
    delay(2000);
    ESP.restart();
  }
}

void loop()
{
  delay(100);
}

Hi reddit :)

We want to do something funny and now I‘m at the point where I need your help.

I need to have a digital waterflow control thingy which I can address via api/directly and tell them to let 1-10 drops of water trough then stop again until next command.

Is there anything buyable for these tiny amounts of water?

And another question: I‘m new to zigbee and I‘m a PHP programmer. How difficult is it to achieve the above mentioned? I believe I need something like a master station or something, which connects the wlan and zigbee, right?

Hi all,

I bought a wall mounted switch for my zigbee spots, but it does not work with the Hue app.

I have 12 spots in my ceiling which work alright, but I want to be able to switch/dim them with buttons. In the Hue app I have split my ceiling into 3 groups of spots, so I bought a wall switch with 4 groups, to operate each individual group or the whole ceiling at once.

Now I discover that the switch will not be visible in the Hue app, so I cannot assign spots to the switches. I can only assign them by pairing each spot seperately with the switches.

Are there switches like this that WILL be visible in the Hue app?