---
title: "Shelly RGBW2"
description: "Shelly RGBW2 sterownik LED RGBW Wi-Fi z dwoma trybami pracy. Steruj taśmami LED RGB lub czterema niezależnymi kanałami białymi przez HTTP z TapHome."
url: "https://taphome.com/pl/compatibility/shelly-rgbw2/"
language: pl
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","lighting","wifi","rgbw","led-controller","dimmer"]
  questions: ["Jak zintegrować Shelly RGBW2 z TapHome?","Jaka jest różnica między trybem Color a White w Shelly RGBW2?","Jak sterować taśmami LED RGB przez TapHome?","Jak ściemniać cztery niezależne kanały białe z Shelly RGBW2 w TapHome?","Dlaczego szablon Shelly RGBW2 pokazuje błąd trybu w TapHome?","Jak ustawić czas przejścia dla zmian światła Shelly RGBW2?"]
---

# Shelly RGBW2

Komunikacja: Packet Parser → HTTP

- [Strona produktu Shelly RGBW2](https://www.shelly.com/en/products/shop/shelly-rgbw2)
- [Dokumentacja API Shelly RGBW2](https://shelly-api-docs.shelly.cloud/gen1/#shelly-rgbw2-color-mode)

> Adres w sieci
> 
> TapHome łączy się z urządzeniem pod adresem podanym przy imporcie. Nadaj urządzeniu stały adres — rezerwację IP w routerze albo jego nazwę mDNS, jeśli ją obsługuje — inaczej integracja przestanie działać, gdy router zmieni adres.
> 
> [Przygotowanie sieci](https://taphome.com/pl/docs/setup/network-preparation/)

## Poradnik integracji

Shelly RGBW2 to sterownik taśm LED RGBW Wi-Fi z czterema wyjściami PWM (12/24 V DC). Obsługuje dwa wzajemnie wykluczające się tryby pracy — Color i White — każdy wymagający własnego szablonu TapHome. TapHome komunikuje się z urządzeniem przez HTTP w sieci lokalnej; połączenie z chmurą nie jest wymagane.

W **trybie Color** cztery wyjścia sterują taśmą LED RGBW jako pojedyncze kolorowe światło z odcieniem, nasyceniem, jasnością i opcjonalnym kanałem białym (CCT). W **trybie White** cztery wyjścia działają jako niezależne ściemniacze, każdy sterujący oddzielną białą taśmą LED lub strefą.

Tryb pracy należy wybrać w interfejsie web Shelly (lub przez API) przed importem odpowiedniego szablonu. Każdy szablon waliduje bieżący tryb przy każdym odpytywaniu i wyświetla błąd, jeśli urządzenie jest ustawione na niewłaściwy tryb.

## Konfiguracja

Oba szablony łączą się przez Wi-Fi. Podczas importu szablonu TapHome wprowadź adres IP urządzenia (domyślny placeholder `192.168.0.1`) i opcjonalny czas przejścia w milisekundach (domyślne `300`).

Parametr czas przejścia kontroluje, jak szybko światło przechodzi między poziomami jasności. Dotyczy wszystkich poleceń zapisu (wł./wył., jasność, zmiany kolorów) i wpływa na okno debounce — szablon ignoruje odpytywane wartości przez `transitionTime + 500 ms` po każdym zapisie, aby zapobiec nieaktualnym odczytom podczas przejść.

## Szablon trybu Color

### Kolorowe światło

Szablon udostępnia taśmę RGBW jako pojedyncze kolorowe światło HSB z dwoma podtrybami:

- **Kolor RGB** — odcień i nasycenie sterują kolorem taśmy. Szablon konwertuje między wartościami RGB API Shelly (czerwony, zielony, niebieski 0-255) a modelem HSB TapHome. Jasność jest sterowana parametrem `gain` (0-100).
- **Biały (CCT)** — gdy ustawiona jest skorelowana temperatura barwowa, szablon przełącza się na sterowanie kanałem białym. Zakres CCT wynosi 3000-6500 K. Jasność jest sterowana parametrem `white` (0-100).

Stan światła odczytywany jest z odpowiedzi `/status` (`lights[0]`) i sterowany przez endpoint `/light/0`. Włączenie wysyła `turn=on` z aktualnymi wartościami koloru lub bieli; wyłączenie wysyła `turn=off`. Wszystkie polecenia zapisu zawierają parametr czas przejścia.

### Pomiar mocy (Color)

Szablon Color zawiera jeden licznik energii odczytujący z `meters[0]`:

- **Moc chwilowa** — `meters[0].power` w watach, konwertowana na kW
- **Całkowite zużycie** — `meters[0].total` w watominutach, konwertowane na kWh

Jeśli światło jest włączone, ale moc pokazuje zero, szablon wyświetla ostrzeżenie z sugestią skonfigurowania modelu urządzenia w ustawieniach aplikacji Shelly.

## Szablon trybu White

### Cztery niezależne ściemniacze

Szablon White udostępnia cztery niezależne kanały ściemniacza, po jednym na wyjście PWM:

| Kanał | Wyjście | Endpoint | Interwał odpytywania |
|-------|---------|----------|----------------------|
| Ch1 | R (Red) | `/light/0` | 2,5 s |
| Ch2 | G (Green) | `/light/1` | 2,5 s |
| Ch3 | B (Blue) | `/light/2` | 2,5 s |
| Ch4 | W (White) | `/light/3` | 2,5 s |

Każdy ściemniacz odczytuje `lights[N].ison` i `lights[N].brightness` (0-100, znormalizowane do 0-1) z odpowiedzi `/status`. Polecenia zapisu używają `/light/N?turn=on|off&brightness=VALUE`. Wszystkie kanały używają tego samego czasu przejścia i logiki debounce.

### Pomiar mocy (White)

Każdy kanał ma własny licznik energii, odczytujący z `meters[0]` do `meters[3]`. Pierwszy kanał odpytuje co 2,5 sekundy; kanały 2-4 odpytują w 15-sekundowych interwałach. Każdy licznik dostarcza moc chwilową (W na kW) i energię skumulowaną (watominuty na kWh).

## Diagnostyka serwisowa

Oba szablony udostępniają 10 atrybutów serwisowych do monitorowania urządzenia:

- **Info sieciowe** — adres IP, adres MAC (formatowany z dwukropkami), siła sygnału Wi-Fi (dB)
- **Łączność** — chmura włączona/połączona, MQTT połączony
- **Info o urządzeniu** — czas urządzenia, czas pracy (formatowany jako dni/godziny/minuty), użycie RAM
- **Firmware** — dostępna aktualizacja firmware

## Akcje serwisowe

Oba szablony współdzielą trzy akcje serwisowe:

- **Włącz chmurę** — włącza lub wyłącza łączność Shelly Cloud
- **Restart** — wyzwala restart urządzenia
- **Ustaw tryb** — szablon Color zawiera „Set mode Color" (`/settings?mode=color`), a szablon White zawiera „Set mode White" (`/settings?mode=white`). Te akcje przełączają tryb pracy urządzenia przez API.

### Dodatkowe funkcje

Shelly RGBW2 udostępnia również efekty świetlne (tryb Color, indeks efektu 0-3), stan wejścia fizycznego, temperaturę wewnętrzną, flagę przegrzania i ustawienia ochrony mocy w swoim API. Te funkcje mogą zostać dodane w przyszłej aktualizacji szablonu.

## Rozwiązywanie problemów

### Urządzenie nie odpowiada

1. Sprawdź, czy Shelly jest podłączony do Wi-Fi i ma prawidłowy adres IP
2. Spróbuj użyć nazwy hosta mDNS (`shellyrgbw2-AABBCCDDEE.local`) zamiast adresu IP — IP mógł się zmienić po odnowieniu DHCP
3. Otwórz `http://{device-ip}/shelly` w przeglądarce — jeśli odpowiada, urządzenie jest dostępne
4. Sprawdź, czy TapHome CCU i Shelly są w tej samej sieci / VLAN

### Błąd „Mode White/Color is not supported"

Ten błąd oznacza, że urządzenie jest ustawione na niewłaściwy tryb pracy dla zaimportowanego szablonu. Rozwiązanie:

1. Otwórz interfejs web Shelly pod adresem `http://{device-ip}`
2. Przełącz tryb pracy, aby odpowiadał szablonowi (Color lub White)
3. Alternatywnie użyj akcji serwisowej „Set mode Color" lub „Set mode White" z drugiego szablonu, aby przełączyć tryb przez API, a następnie reimportuj prawidłowy szablon

### Moc pokazuje zero

1. Potwierdź, że diody LED są podłączone do wyjść Shelly RGBW2
2. Otwórz aplikację Shelly lub interfejs web i zweryfikuj, że model urządzenia jest skonfigurowany w Settings -> Device Model
3. Sprawdź, czy światło jest włączone — licznik mierzy tylko gdy prąd przepływa przez wyjścia
4. Odpytaj `/status` ręcznie i zweryfikuj, że `meters[0].power` zwraca wartość różną od zera

### Kolorowe światło się nie zmienia

1. Sprawdź, czy urządzenie jest w trybie Color (sprawdź odpowiedź `/status` — `mode` powinno być `"color"`)
2. Upewnij się, że światło jest włączone przed zmianą odcienia lub nasycenia
3. Jeśli zarówno `gain`, jak i `white` są niezerowe, szablon automatycznie zeruje je i wyłącza światło — zapobiega to nieokreślonemu zachowaniu, gdy kanały RGB i biały rywalizują

> [!WARNING]
> Urządzenia Shelly Gen1 obsługują tylko **2 jednoczesne połączenia HTTP**. Jeśli TapHome i inny system (np. Home Assistant) odpytują to samo urządzenie jednocześnie, komunikacja może być zawodna. Jeśli urządzenie odpytuje także inny system, zwiększ interwały odpytywania w szablonie (domyślnie 2,5 s dla kanałów światła), aby zmniejszyć rywalizację o połączenia.

## Jak zainstalować w TapHome

### Wymagania wstępne

- Urządzenie Shelly zainstalowane i włączone
- Lokalna sieć Wi-Fi (2,4 GHz)
- TapHome CCU w tej samej sieci

### Krok 1 — Podłącz Shelly do Wi-Fi

**Opcja A — Aplikacja Shelly (zalecana):**

1. Pobierz [aplikację Shelly](https://www.shelly.com/en/support/shelly-app) (iOS / Android)
2. Dotknij **+** → **Add Device** i postępuj zgodnie z kreatorem parowania Bluetooth
3. Wprowadź dane logowania Wi-Fi, gdy zostaniesz o to poproszony

**Opcja B — Tryb AP (bez aplikacji):**

1. Przy pierwszym uruchomieniu urządzenie tworzy hotspot: `ShellyXXX-AABBCCDDEE`
2. Połącz telefon/PC z tym hotspotem
3. Otwórz `http://192.168.33.1` → **Internet & Security** → **Wi-Fi Mode - Client**
4. Wprowadź SSID i hasło → **Save**

> [!NOTE]
> Shelly obsługuje tylko sieci **2,4 GHz**. Sieci 5 GHz nie pojawią się podczas skanowania.

### Krok 2 — Znajdź adres IP

Po połączeniu z Wi-Fi znajdź przypisany adres IP za pomocą jednej z poniższych metod:

- **Aplikacja Shelly:** Szczegóły urządzenia → **Device info** → Adres IP
- **Interfejs webowy Shelly:** Połącz się z AP urządzenia przed konfiguracją Wi-Fi — IP zostanie wyświetlone po zapisaniu
- **Tabela DHCP routera:** Szukaj nazwy hosta takiej jak `shelly1pm-AABBCCDDEE`
- **mDNS:** Pinguj `shelly<model>-<mac>.local` (np. `shelly1pm-AABBCCDDEE.local`) z tej samej sieci

> [!TIP]
> Przypisz urządzeniu Shelly **statyczny IP** (rezerwację DHCP) w routerze, aby adres nie zmieniał się po ponownym uruchomieniu routera.

### Krok 3 — Konfiguracja w TapHome

1. W TapHome dodaj nowy moduł **Packet Parser (HTTP)**
2. **IP Address:** wprowadź IP z kroku 2 (np. `192.168.1.50`)
3. **Port:** `80` (domyślny, nie wymaga zmiany)
4. Zaimportuj szablon — TapHome będzie okresowo odpytywać `/status` w celu odczytu stanu urządzenia

> [!NOTE]
> Uwierzytelnianie HTTP jest domyślnie wyłączone na urządzeniach Shelly. Jeśli włączyłeś ochronę logowaniem, TapHome obecnie nie obsługuje HTTP Basic Auth — pozostaw uwierzytelnianie wyłączone dla integracji z TapHome.

## Dostępne urządzenia 2

Te urządzenia pojawią się w TapHome po imporcie.

Shelly RGBW2 Color Moduł

Atrybuty serwisowe

|                          |
|--------------------------|
| Adres IP                 |
| Adres MAC                |
| Sygnał WiFi              |
| Chmura włączona          |
| Chmura połączona         |
| MQTT połączony           |
| Czas urządzenia          |
| Dostępna aktualizacja FW |
| Czas pracy               |
| RAM                      |

Akcje serwisowe

|                  |
|------------------|
| Włącz chmurę     |
| Restart          |
| Ustaw tryb Color |

Zmienne niestandardowe

|                                             |                                                                                     |
|---------------------------------------------|-------------------------------------------------------------------------------------|
| `transitionTime` (numeric) = TransitionTime | Czas trwania przejścia światła w milisekundach (parametr importu, domyślnie 300 ms) |

Odczyt (moduł)

```taphome
VAR now := NOW();

IF now.Ticks < debounceTimestamp
    RETURN(0);
END

VAR response := SENDHTTPREQUEST("/status");

IF response.IsSuccess
    jsonStatus := response.Content;
    
    if PARSEJSON(jsonStatus, "$.mode", 1) = "white"
    adderror("Mode White is not supported");
    end
ELSE
    jsonStatus := NULL;
END
```

Atrybuty serwisowe

IP Address

```taphome
VAR response := SENDHTTPREQUEST("/status");

IF response.IsSuccess
    jsonStatus := response.Content;
ELSE
    jsonStatus := NULL;
END

VAR address := PARSEJSON(jsonStatus, "$.wifi_sta.ip", 1);
IF (ISNULL(address), "-", address)
```

MAC Address

```taphome
VAR value := PARSEJSON(jsonStatus, "$.mac", 1);
IF ISNULL(value)
    RETURN("-");
END;

STRING mac;
INT i := 0;
INT len := LENGTH(value);

WHILE i < len
    mac += GETAT(value, i);
    i += 1;
    
    IF MOD(i, 2) = 0 AND i < len
        mac += ":";
    END
LOOP

mac
```

WIFI signal

```taphome
VAR signal := PARSEJSON(jsonStatus, "$.wifi_sta.rssi", 1);
IF (ISNULL(signal), "-", signal + "db");
```

Cloud enabled

```taphome
VAR value := PARSEJSON(jsonStatus, "$.cloud.enabled", 1);
IF (ISNULL(value), "-", value)
```

Cloud connected

```taphome
VAR value := PARSEJSON(jsonStatus, "$.cloud.connected", 1);
IF (ISNULL(value), "-", value)
```

MQTT connected

```taphome
VAR value := PARSEJSON(jsonStatus, "$.mqtt.connected", 1);
IF (ISNULL(value), "-", value)
```

Device time

```taphome
VAR value := PARSEJSON(jsonStatus, "$.time", 1);
IF (ISNULL(value), "-", value)
```

FW update available

```taphome
VAR value := PARSEJSON(jsonStatus, "$.has_update");
IF (ISNULL(value), "-", value)
```

Uptime

```taphome
VAR value := PARSEJSON(jsonStatus, "$.uptime", 1);
IF ISNULL(value)
    RETURN("-");
END

VAR days := FLOOR(value/86400, 1);
value := MOD(value, 86400);
VAR hours := FLOOR(value/3600, 1);
value := MOD(value, 3600);
VAR minutes := FLOOR(value/60, 1);

days + "day(s) " + hours + "h " + minutes + "m"
```

RAM

```taphome
VAR ramFree := PARSEJSON(jsonStatus, "$.ram_free", 1);
VAR ramTotal := PARSEJSON(jsonStatus, "$.ram_total", 1);

IF ISNULL(ramFree) OR ISNULL(ramTotal)
    RETURN("-");
END

ramFree + " bytes free of " + ramTotal
```

Akcje serwisowe

Enable cloud

Parametry: Enable (Enable / Disable)

```taphome
VAR response := SENDHTTPREQUEST("/settings/cloud?enabled=" + enable);
VAR contentJson := response.Content;
VAR wasEnabled := PARSEJSON(contentJson, "enabled");

IF(wasEnabled, "Cloud enabled", "Cloud disabled");
```

Reboot

```taphome
VAR response := SENDHTTPREQUEST("/reboot");
VAR contentJson := response.Content;
VAR wasRebooted := PARSEJSON(contentJson, "ok");

IF(wasRebooted, "Reboot successful", "Error");
```

Set mode Color

```taphome
VAR response := SENDHTTPREQUEST("/settings?mode=color");
IF(response.isSuccess, "Color mode is set", "Error");
```

Licznik energii Licznik energii Tylko do odczytu

Pomiar zużycia energii — moc chwilowa (kW) i energia skumulowana (kWh)

numeric Jednostka: W / kWh

Odczyt całkowitego zużycia

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[0].power");
VAR total := PARSEJSON(jsonStatus, "$.meters[0].total");
BOOL isOn := PARSEJSON(jsonStatus, "$.lights[0].ison");

IF ISNULL(power) OR ISNULL(total) OR (ison AND power=0)
	ADDWARNING("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model");
	
    RETURN(NaN);
END

total / 60000.0
```

Odczyt zapotrzebowania

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[0].power", 1);

IF ISNULL(power)
    RETURN(NaN);
END

power / 1000.0
```

Kolorowe światło Światło HSB Odczyt i zapis

Kolorowe światło RGBW ze sterowaniem HSB — odcień, nasycenie, jasność i opcjonalny kanał biały CCT (3000–6500 K)

hsb

Odczyt (moduł)

```taphome
if PARSEJSON(jsonStatus, "$.lights[0].white", 1) > 0 and PARSEJSON(jsonStatus, "$.lights[0].gain", 1)
    SENDHTTPREQUEST("light/0?gain=0&white=0");
    SENDHTTPREQUEST("light/0?turn=off");
end
```

Odczyt jasności

```taphome
VAR now := NOW();

IF now.Ticks < debounceTimestamp
    RETURN(Hb);
END

INT value;
IF !ISNAN(Ct)
    value := PARSEJSON(jsonStatus, "$.lights[0].white", 1);
ELSE
    value := PARSEJSON(jsonStatus, "$.lights[0].gain", 1);
END

IF ISNULL(value)
    RETURN(NaN);
END

BOOL isOn := PARSEJSON(jsonStatus, "$.lights[0].ison", 1);

IF ISNULL(isOn)
    RETURN(NaN);
END

IF(isOn, value/100.0, 0);
```

Zapis jasności

```taphome
IF St > 0.5
    IF !ISNAN(Ct)
    SENDHTTPREQUEST("light/0?turn=on&transition=" + transitionTime + "&gain=0&white=" + ROUND(Hb*100.0));
    ELSE
    SENDHTTPREQUEST("light/0?turn=on&transition=" + transitionTime + "&white=0&gain=" + ROUND(Hb*100.0));
    END
ELSE
    SENDHTTPREQUEST("light/0?turn=off&transition=" + transitionTime);
END

VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

Odczyt odcienia

```taphome
VAR now := NOW();

IF now.Ticks < debounceTimestamp
    RETURN(Hd);
END

INT r := PARSEJSON(jsonStatus, "$.lights[0].red", 1);
INT g := PARSEJSON(jsonStatus, "$.lights[0].green", 1);
INT b := PARSEJSON(jsonStatus, "$.lights[0].blue", 1);

VAR HSVColor := RGBTOHSV(r, g, b);
ROUND(HSVColor.Hue);
```

Zapis odcienia

```taphome
IF !ISNAN(Ct)
    RETURN(0);
END

VAR color := HSVTORGB(Hd, Sa, 1);

SENDHTTPREQUEST("light/0?mode=color&transition=" + transitionTime + "&gain=" + ROUND(Hb*100) + "&red=" + color.RED + "&green=" + color.GREEN + "&blue=" + color.BLUE + "&white=0");


VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

Odczyt nasycenia

```taphome
VAR now := NOW();

IF now.Ticks < debounceTimestamp
    RETURN(Sa);
END

INT r := PARSEJSON(jsonStatus, "$.lights[0].red", 1);
INT g := PARSEJSON(jsonStatus, "$.lights[0].green", 1);
INT b := PARSEJSON(jsonStatus, "$.lights[0].blue", 1);
 
VAR HSVColor := RGBTOHSV(r, g, b);
ROUND(HSVColor.Saturation * 100.0) / 100.0;
```

Zapis nasycenia

```taphome
IF !ISNAN(Ct)
    RETURN(0);
END

VAR color := HSVTORGB(Hd, Sa, 1);

SENDHTTPREQUEST("light/0?mode=color&transition=" + transitionTime + "&gain=" + ROUND(Hb*100) + "&red=" + color.RED + "&green=" + color.GREEN + "&blue=" + color.BLUE + "&white=0");


VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

Odczyt temperatury barwowej

```taphome
VAR now := NOW();

IF now.Ticks < debounceTimestamp
    RETURN(Ct);
END

INT value := PARSEJSON(jsonStatus, "$.lights[0].temp", 1);
IF PARSEJSON(jsonStatus, "$.lights[0].white", 1) = 0
    RETURN(NaN);
END
 
Ct
```

Zapis temperatury barwowej

```taphome
IF ISNAN(Ct)
    RETURN(0);
END

VAR temp := MIN(Ct, 6500);
temp := MAX(temp, 3000);

SENDHTTPREQUEST("light/0?transition=" + transitionTime + "&white=" + ROUND(Hb*100) + "&gain=0");

VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

**Połączenie:** Packet Parser → HTTP • Hostname: `shellyrgbw2-{MAC}.local`

Możliwe ulepszenia (7)

- Light effect — Color mode: effect index (0=off, 1–3=predefined effects), settable via /light/0?effect=N
- Input State — Physical input state (0/1), available in /status response
- WiFi RSSI (numeric) — WiFi RSSI in dBm as numeric value — template reads it as string with 'db' suffix
- Power protection — Max power setting in Watts, available in /settings; read + write possible via /settings?max\_power=N
- OTA firmware update — Trigger OTA firmware update via /ota?update=true
- Internal device temperature — Internal temperature in C, available in /status response (Gen1 devices)
- Overheated — Overtemperature flag, boolean, available in /status response

## Parametry importu

Te wartości podajesz podczas importu pliku XML.

| Pytanie w aplikacji  | Domyślnie     |
|----------------------|---------------|
| Adres IP             | `192.168.0.1` |
| Transition time (ms) | `300`         |

## Źródła

- Shelly Gen1 API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/) 2026-03-12
- Home Assistant Shelly Integration
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-12
- Shelly RGBW2 API — Color & White Mode Endpoints
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-rgbw2-color-mode) 2026-03-30
- Shelly RGBW2 Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-rgbw2) 2026-03-30

## Powiązana dokumentacja

- [Integracja Packet Parser](https://taphome.com/pl/compatibility/packet-parser-guide/)
- [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/pl/docs/integration/packet-parser/)
- [Funkcje Packet parser](https://taphome.com/pl/docs/script/packet-parser/)
- [Funkcje parsowania](https://taphome.com/pl/docs/script/parsing-functions/)