---
title: "Shelly 2PM Gen3"
description: "Shelly 2PM Gen3 w TapHome lokalnie przez HTTP RPC: dwa przekaźniki z pomiarem mocy albo roleta i żaluzja z pozycją i lamelami. Bez chmury."
url: "https://taphome.com/pl/compatibility/shelly-2pm-gen3/"
language: pl
lastmod: 2026-03-29
generator: hugo
ai:
  topics: ["http","electric-meter","wifi","relay","power-metering","cover","blind","mdns","profile"]
  questions: ["Jak zintegrować Shelly 2PM Gen3 z TapHome?","Jaka jest różnica między profilem switch a cover na Shelly 2PM Gen3?","Jak sterować zmotoryzowaną żaluzją za pomocą Shelly 2PM Gen3 i TapHome?","Jak przełączyć między trybem przekaźnika a rolety na Shelly 2PM Gen3?","Dlaczego szablon Shelly 2PM Gen3 pokazuje błąd profilu w TapHome?","Jak skalibrować roletę Shelly 2PM Gen3 do sterowania pozycją?"]
---

# Shelly 2PM Gen3

Komunikacja: Packet Parser → HTTP

- [Strona produktu Shelly 2PM Gen3](https://www.shelly.com/en/products/shop/shelly-2-pm-gen3)

> 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 2PM Gen3 to kompaktowy dwukanałowy moduł przekaźnikowy Wi-Fi z wbudowanym pomiarem mocy. Mieści się za standardowym przełącznikiem ściennym i może sterować dwoma niezależnymi obwodami do 10 A każdy (łącznie 16 A przy 230 V AC) lub jedną zmotoryzowaną roletą/żaluzją. TapHome komunikuje się z urządzeniem przez HTTP za pomocą API Gen2+/Gen3 JSON-RPC 2.0 w sieci lokalnej — połączenie z chmurą nie jest wymagane.

Urządzenie obsługuje dwa profile pracy — **switch** i **cover** — wybierane przez interfejs webowy Shelly lub akcję serwisową TapHome. W profilu switch oba wyjścia przekaźnikowe (O1 i O2) działają niezależnie z pomiarem mocy na kanał. W profilu cover dwa wyjścia napędzają jeden silnik do rolet, żaluzji lub zasłon, ze sterowaniem pozycją, obsługą lameli i kalibracją.

W odróżnieniu od Shelly 1PM Gen3, który steruje jednym obwodem, 2PM Gen3 zapewnia sterowanie dwukanałowe lub obsługę zmotoryzowanej rolety. Oba dzielą tę samą platformę Gen3 z procesorem ESP (8 MB flash), do 6 jednoczesnych połączeń HTTP i możliwością aktualizacji do Matter.

## Konfiguracja

Shelly 2PM Gen3 łączy się przez Wi-Fi. Podczas importu szablonu do TapHome wprowadź adres IP urządzenia (domyślny placeholder `192.168.0.1`).

> [!WARNING]
> Uwierzytelnianie musi być **wyłączone** na urządzeniu Shelly dla integracji z TapHome. TapHome nie obsługuje HTTP Digest Auth używanego przez urządzenia Gen2+/Gen3. Otwórz interfejs webowy Shelly (`http://{device-ip}`) → Settings → Authentication i upewnij się, że jest wyłączone.

> [!NOTE]
> Jeśli tryb ECO jest włączony na urządzeniu Shelly, może powodować timeouty komunikacji z powodu szybkich interwałów odpytywania szablonu (2,5–3 sekundy). Wyłącz tryb ECO w interfejsie webowym Shelly, jeśli doświadczasz przerywanych problemów z łącznością.

### Wybór profilu

Shelly 2PM Gen3 pracuje w jednym z dwóch profili naraz. Aktywny profil określa, które urządzenia TapHome są funkcjonalne:

- **Profil switch** — aktywuje oba przełączniki przekaźnikowe (Przełącznik 1 i Przełącznik 2) z niezależnym pomiarem mocy. Urządzenia rolety i żaluzji będą wyświetlać błąd profilu.
- **Profil cover** — aktywuje roletę i żaluzję. Urządzenia przełączników będą wyświetlać błąd profilu.

Aktywny profil jest widoczny jako atrybut serwisowy na poziomie modułu („Profil") w TapHome. Aby zmienić profil, użyj akcji serwisowej **Ustaw profil** na poziomie modułu lub przełącz go w interfejsie webowym Shelly. Po zmianie profilu urządzenie restartuje się i tylko urządzenia odpowiadające nowemu profilowi będą działać bez błędów.

> [!TIP]
> Szablon zawiera wszystkie cztery typy urządzeń (2 przełączniki + roleta + żaluzja), ale działać będą tylko urządzenia odpowiadające aktywnemu profilowi. Urządzenia w niewłaściwym profilu wyświetlają komunikat błędu, np. „Profile is not set to switch" lub „Profile is not set to cover" — to oczekiwane zachowanie, nie awaria.

### Kalibracja rolety

Przy użyciu profilu cover limity ruchu silnika muszą być skalibrowane przed działaniem sterowania pozycją. Dopóki kalibracja nie zostanie zakończona, szablon wyświetli błąd „Calibration is required". Skalibruj przez interfejs webowy Shelly lub uruchamiając akcję serwisową **Uruchom automatyczną kalibrację** w TapHome. Podczas kalibracji roleta przejedzie całkowicie w górę i całkowicie w dół, aby zmierzyć odległości.

## Możliwości urządzeń

### Sterowanie przekaźnikiem (profil switch)

Szablon udostępnia dwa niezależne przełączniki przekaźnikowe. Każdy przełącznik odczytuje swój stan z `/rpc/Switch.GetStatus?id={0,1}` (pole `output`, boolean) i steruje przekaźnikiem przez `/rpc/Switch.Set?id={0,1}&on=true|false`.

Każdy przełącznik udostępnia również atrybuty serwisowe do monitorowania na kanał:

- **Temperatura** — wewnętrzna temperatura urządzenia w °C (`temperature.tC`)
- **Zużycie energii** — energia skumulowana w Wh (`aenergy.total`)
- **Pobór mocy** — moc chwilowa w W (`apower`)
- **Napięcie elektryczne** — napięcie zasilania w V (`voltage`)
- **Prąd elektryczny** — prąd obciążenia w A (`current`)
- **Częstotliwość** — częstotliwość sieci AC w Hz (`freq`)
- **Współczynnik mocy** — wartość współczynnika mocy (`pf`)

Przełączniki aktualizują się co 2,5 sekundy.

### Sterowanie roletą (profil cover)

Urządzenie rolety steruje zmotoryzowaną roletą, zasłoną lub markizą. Odczytuje pozycję z `/rpc/Cover.GetStatus?id=0` (pola `current_pos` i `target_pos`, 0–100) i zapisuje przez `/rpc/Cover.GoToPosition?id=0&pos=N`. Szablon odwraca skalę pozycji tak, że 0 = całkowicie otwarta i 100 = całkowicie zamknięta w TapHome.

Roleta udostępnia atrybuty serwisowe:

- **Temperatura** — wewnętrzna temperatura urządzenia w °C
- **Zużycie energii** — energia skumulowana silnika w Wh
- **Pobór mocy** — moc chwilowa silnika w W
- **Napięcie elektryczne** — napięcie zasilania w V
- **Prąd elektryczny** — prąd silnika w A

Akcja serwisowa **Uruchom automatyczną kalibrację** jest dostępna do uruchomienia kalibracji bezpośrednio z TapHome.

### Sterowanie żaluzją (profil cover)

Urządzenie żaluzji rozszerza roletę o sterowanie nachyleniem lameli dla żaluzji poziomych. Oprócz pozycji odczytuje i zapisuje pozycję lameli (`slat_pos`) przez `/rpc/Cover.GoToPosition?id=0&pos=N&slat_pos=M`. Obie skale pozycji i nachylenia są odwrócone (0 = otwarta, 100 = zamknięta w TapHome).

Żaluzja udostępnia te same atrybuty serwisowe co roleta, plus:

- **Lamela** — pokazuje, czy sterowanie lamelami jest włączone lub wyłączone (z `Cover.GetConfig → $.slat.enable`)
- **Czas otwarcia lameli** — skonfigurowany czas otwierania lameli w sekundach
- **Czas zamknięcia lameli** — skonfigurowany czas zamykania lameli w sekundach

> [!NOTE]
> **Znany problem szablonu:** Atrybut serwisowy „Slat close time" odczytuje `$.slat.open_time` zamiast `$.slat.close_time` z konfiguracji Cover. Oba atrybuty czasu lameli obecnie wyświetlają tę samą wartość (czas otwarcia). Zostanie to naprawione w przyszłej rewizji szablonu.

Dwie akcje serwisowe są dostępne na urządzeniu żaluzji:

- **Uruchom automatyczną kalibrację** — uruchamia kalibrację pozycji rolety
- **Ustaw lamelę** — włącza sterowanie lamelami i konfiguruje czasy otwarcia/zamknięcia (0,1–5 sekund każdy) przez `/rpc/Cover.SetConfig`

> [!WARNING]
> Sterowanie lamelami musi być włączone, zanim urządzenie żaluzji będzie mogło sterować nachyleniem. Jeśli pozycja lameli nie jest dostępna z urządzenia, żaluzja wyświetli błąd „Slat position must be enabled for blinds". Użyj akcji serwisowej **Ustaw lamelę**, aby ją włączyć i ustawić czasy otwarcia/zamknięcia.

### Diagnostyka serwisowa

Szablon udostępnia atrybuty serwisowe na poziomie modułu do monitorowania urządzenia:

- **WiFi** — nazwa podłączonej sieci SSID
- **Adres IP** — aktualny adres IP stacji
- **Siła sygnału** — WiFi RSSI w dB
- **MAC** — adres MAC urządzenia
- **Profil** — aktualnie aktywny profil urządzenia (switch lub cover)

Skrypt odczytu modułu sprawdza również dostępność aktualizacji firmware i oczekujące wymagania restartu, wyświetlając je jako ostrzeżenia w interfejsie TapHome.

### Akcje serwisowe

Trzy akcje serwisowe są dostępne na poziomie modułu:

- **Aktualizacja firmware** — uruchamia aktualizację firmware do najnowszej stabilnej wersji przez `/rpc/Shelly.Update`
- **Restart** — uruchamia restart urządzenia przez `/rpc/Shelly.Reboot`
- **Ustaw profil** — przełącza między trybami pracy cover i switch przez `/rpc/Shelly.SetProfile`

### Dodatkowe możliwości

Shelly 2PM Gen3 udostępnia również stany fizycznych wejść (`input:0`, `input:1`), liczniki energii zwrotnej/eksportowanej, czas pracy, wykorzystanie RAM i czas urządzenia w swoich odpowiedziach RPC. Timer auto-off jest dostępny przez parametr `toggle_after`, ochrona przed przeciążeniem można skonfigurować przez `Switch.SetConfig → power_limit`, a liczniki energii można zresetować przez `/rpc/Switch.ResetCounters`. W trybie cover dostępne są bezpośrednie polecenia open/close/stop i stan ruchu rolety (open/opening/closed/closing/stopped/calibrating). Te możliwości mogą zostać dodane w przyszłej aktualizacji szablonu.

## Rozwiązywanie problemów

### Urządzenie nie odpowiada

1. Sprawdź, czy Shelly jest połączony z Wi-Fi i ma prawidłowy adres IP
2. Spróbuj użyć nazwy hosta mDNS (`shelly2pmg3-AABBCCDDEE.local`) zamiast adresu IP — IP mógł się zmienić po odnowieniu DHCP
3. Otwórz `http://{device-ip}/rpc/Shelly.GetDeviceInfo` w przeglądarce — jeśli odpowie JSON-em, urządzenie jest osiągalne
4. Sprawdź, czy TapHome Core i Shelly są w tej samej sieci / VLAN
5. Potwierdź, że uwierzytelnianie jest wyłączone na urządzeniu Shelly

### Błędy niezgodności profilu

Jeśli urządzenie wyświetla „Profile is not set to switch" lub „Profile is not set to cover":

1. Sprawdź, który profil jest aktualnie aktywny — atrybut serwisowy „Profil" na poziomie modułu pokazuje aktualny tryb
2. Przełącz na właściwy profil za pomocą akcji serwisowej **Ustaw profil** lub usuń nieużywane urządzenia z TapHome
3. Po przełączeniu profili urządzenie restartuje się automatycznie — odczekaj kilka sekund na ponowne połączenie

### Sterowanie pozycją rolety nie działa

1. Sprawdź, czy urządzenie jest w profilu cover — profil switch nie udostępnia funkcjonalności rolety
2. Uruchom akcję serwisową **Uruchom automatyczną kalibrację** — sterowanie pozycją wymaga ukończonej kalibracji
3. Sprawdź, czy silnik jest prawidłowo podłączony do zacisków O1 i O2
4. Odpytaj `/rpc/Cover.GetStatus?id=0` ręcznie i sprawdź, czy `pos_control` to `true`

### Nachylenie żaluzji nie reaguje

1. Potwierdź, że sterowanie lamelami jest włączone — sprawdź atrybut serwisowy „Lamela" (powinien pokazywać „Enabled")
2. Jeśli wyłączone, użyj akcji serwisowej **Ustaw lamelę** do włączenia i konfiguracji czasów otwarcia/zamknięcia
3. Sprawdź, czy silnik żaluzji obsługuje operację nachylenia — rolety bez nachylenia ignorują polecenia lameli

### Ostrzeżenie o przegrzaniu

Shelly 2PM Gen3 ma wewnętrzną ochronę termiczną. Jeśli temperatura urządzenia przekroczy bezpieczne limity, wartość `temperature` w atrybutach serwisowych urządzenia wzrośnie. Zapewnij odpowiednią wentylację wokół urządzenia, szczególnie przy przełączaniu dużych obciążeń. Maksymalny prąd przełączania wynosi 10 A na kanał, łącznie 16 A (18 A szczytowo).

> [!WARNING]
> Urządzenia Shelly Gen2+/Gen3 obsługują do **6 jednoczesnych połączeń HTTP**. Choć jest to znaczna poprawa w stosunku do Gen1 (2 połączenia), unikaj odpytywania z zbyt wielu systemów jednocześnie (TapHome, Home Assistant, własne skrypty), aby zapobiec wyczerpaniu połączeń. Szablon Shelly 2PM Gen3 używa do 4 jednoczesnych endpointów na cykl odpytywania, co pozostawia ograniczony margines na dodatkowe 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 4

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

Shelly 2PM Gen3 Moduł

Atrybuty serwisowe

|              |                                                                                                   |
|--------------|---------------------------------------------------------------------------------------------------|
| WiFi         |                                                                                                   |
| Adres IP     |                                                                                                   |
| Siła sygnału |                                                                                                   |
| MAC          |                                                                                                   |
| Profil       | Aktywny profil urządzenia — switch (podwójny przekaźnik) lub cover (zmotoryzowana żaluzja/roleta) |

Akcje serwisowe

|                       |                                                                                           |
|-----------------------|-------------------------------------------------------------------------------------------|
| Aktualizacja firmware |                                                                                           |
| Restart               |                                                                                           |
| Ustaw profil          | Przełączanie między trybami cover i switch — urządzenie restartuje się po zmianie profilu |

Zmienne niestandardowe

Odczyt (moduł)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Sys.GetStatus");
IF response.IsSuccess
    Sys.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/Sys.GetConfig");
IF response.IsSuccess
    Sys.GetConfig := response.Content;
END

response := SENDHTTPREQUEST("/rpc/WiFi.GetStatus");
IF response.IsSuccess
    WiFi.GetStatus := response.Content;
END

if ! ISNULL(parsejson(Sys.GetStatus, "available_updates.stable", true))
    addwarning("New firmware update is available");
end

if parsejson(Sys.GetStatus, "restart_required", true)
    addwarning("Restart required");
end
```

Atrybuty serwisowe

Wifi

```taphome
PARSEJSON(WiFi.GetStatus, "ssid")
```

${ipAddress}

```taphome
PARSEJSON(WiFi.GetStatus, "sta_ip")
```

${xml\_signal\_strength} \[dB]

```taphome
PARSEJSON(WiFi.GetStatus, "rssi")
```

MAC

```taphome
PARSEJSON(Sys.GetStatus, "mac")
```

Profile

```taphome
PARSEJSON(Sys.GetConfig, "$.device.profile");
```

Akcje serwisowe

${xml\_update\_fw}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Update?stage=\"stable\"");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END

```

${restart}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Reboot");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Set Profile

Parametry: Profile

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.SetProfile?name=\"" + 
switch(prof,
0, "cover",
1, "switch",
"")
+ "\"");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Przełącznik 1 Przełącznik Odczyt i zapis

Wyjście przekaźnikowe 1 z pomiarem mocy na kanał — wymaga profilu switch

boolean

Wartości / Stany: ON · OFF

Odczyt stanu przełącznika

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END
return(PARSEJSON(Switch.GetStatus, "$.output", true));
```

Zapis stanu przełącznika

```taphome
VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=" + ID + "&on=" + if(St,"true","false"));
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END
```

Odczyt (moduł)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "switch"
	adderror("Profile is not set to switch (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END

response := SENDHTTPREQUEST("/rpc/Switch.GetConfig?id=" + ID);
IF response.IsSuccess
    Switch.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Switch.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Switch.GetStatus, "errors"));
end
```

Atrybuty serwisowe

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Switch.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Switch.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Switch.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Switch.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Switch.GetStatus, "$.current", true)
```

${frequency} \[Hz]

```taphome
parsejson(Switch.GetStatus, "$.freq", true)
```

Power Factor

```taphome
parsejson(Switch.GetStatus, "$.pf", true)
```

Przełącznik 2 Przełącznik Odczyt i zapis

Wyjście przekaźnikowe 2 z pomiarem mocy na kanał — wymaga profilu switch

boolean

Wartości / Stany: ON · OFF

Odczyt stanu przełącznika

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END
return(PARSEJSON(Switch.GetStatus, "$.output", true));
```

Zapis stanu przełącznika

```taphome
VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=" + ID + "&on=" + if(St,"true","false"));
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END
```

Odczyt (moduł)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "switch"
	adderror("Profile is not set to switch (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END

response := SENDHTTPREQUEST("/rpc/Switch.GetConfig?id=" + ID);
IF response.IsSuccess
    Switch.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Switch.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Switch.GetStatus, "errors"));
end
```

Atrybuty serwisowe

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Switch.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Switch.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Switch.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Switch.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Switch.GetStatus, "$.current", true)
```

${frequency} \[Hz]

```taphome
parsejson(Switch.GetStatus, "$.freq", true)
```

Power Factor

```taphome
parsejson(Switch.GetStatus, "$.pf", true)
```

Roleta Suwak Odczyt i zapis

Zmotoryzowana roleta lub zasłona ze sterowaniem pozycją — wymaga profilu cover i kalibracji

numeric Jednostka: %

Atrybuty serwisowe

|                      |
|----------------------|
| Temperatura          |
| Zużycie energii      |
| Pobór mocy           |
| Napięcie elektryczne |
| Prąd elektryczny     |

Akcje serwisowe

|                                 |
|---------------------------------|
| Uruchom automatyczną kalibrację |

Odczyt (moduł)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "cover"
	adderror("Profile is not set to cover (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + ID);
IF response.IsSuccess
    Cover.GetStatus := response.Content;  
END

response := SENDHTTPREQUEST("/rpc/Cover.GetConfig?id=" + ID);
IF response.IsSuccess
    Cover.GetConfig := response.Content;
END

if ! parsejson(Cover.GetStatus, "$.pos_control", true)
    #adderror("${presence_calibration_required}");
    adderror("Calibration is required");
end

if ! ISNULL(parsejson(Cover.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Cover.GetStatus, "errors"));
end
```

Odczyt poziomu rolety

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
if ! isnull(PARSEJSON(Cover.GetStatus, "$.target_pos", true))
	pos := PARSEJSON(Cover.GetStatus, "$.target_pos", true);
end

return(linear(pos,0,1,100,0));
```

Zapis poziomu rolety

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=" + ID + "&pos=" + round(linear(Bl,0,100,1,0)));
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END

response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + ID);
IF response.IsSuccess
    Cover.GetStatus := response.Content;  
END
```

Atrybuty serwisowe

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Cover.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Cover.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Cover.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Cover.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Cover.GetStatus, "$.current", true)
```

Akcje serwisowe

${start\_automatic\_calibration}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Cover.Calibrate?id=" + ID);
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Żaluzja Roleta Odczyt i zapis

Żaluzja ze sterowaniem pozycją i nachyleniem lameli — wymaga profilu cover, kalibracji i włączonych lameli

numeric Jednostka: %

Atrybuty serwisowe

|                        |                                                                             |
|------------------------|-----------------------------------------------------------------------------|
| Temperatura            |                                                                             |
| Zużycie energii        |                                                                             |
| Pobór mocy             |                                                                             |
| Napięcie elektryczne   |                                                                             |
| Prąd elektryczny       |                                                                             |
| Lamela                 | Czy sterowanie nachyleniem lameli jest włączone w konfiguracji Shelly Cover |
| Czas otwarcia lameli   |                                                                             |
| Czas zamknięcia lameli |                                                                             |

Akcje serwisowe

|                                 |                                                                                 |
|---------------------------------|---------------------------------------------------------------------------------|
| Uruchom automatyczną kalibrację |                                                                                 |
| Ustaw lamelę                    | Włącz sterowanie lamelami i skonfiguruj czas otwarcia/zamknięcia (0,1–5 sekund) |

Odczyt (moduł)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "cover"
	adderror("Profile is not set to cover (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + ID);
IF response.IsSuccess
    Cover.GetStatus := response.Content;  
END

response := SENDHTTPREQUEST("/rpc/Cover.GetConfig?id=" + ID);
IF response.IsSuccess
    Cover.GetConfig := response.Content;
END

if ! parsejson(Cover.GetStatus, "$.pos_control", true)
    #adderror("${presence_calibration_required}");
    adderror("Calibration is required");
end

if ! ISNULL(parsejson(Cover.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Cover.GetStatus, "errors"));
end
```

Odczyt poziomu rolety

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
var target := PARSEJSON(Cover.GetStatus, "$.target_pos", true);
var slatPos := PARSEJSON(Cover.GetStatus, "$.slat_pos", true);

BlSend := 0;
if BsSend = 0 and (Bs = 0 or Bs = 1) 
	if (!isnull(target))
		DeltaPos := 0;
		return(linear(target,0,1,100,0));
	else
		return(linear(pos - DeltaPos,0,1,100,0));	
	end
end

return(Bl);
```

Zapis poziomu rolety

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
var target := PARSEJSON(Cover.GetStatus, "$.target_pos", true);
var slatPos := PARSEJSON(Cover.GetStatus, "$.slat_pos", true);

VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=0&pos=" + round(linear(Bl,0,100,1,0)));
BlSend := 1;
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END

#response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=0");
#IF response.IsSuccess
#    Cover.GetStatus := response.Content;  
#END
```

Odczyt nachylenia lameli

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
var slatPos := PARSEJSON(Cover.GetStatus, "$.slat_pos", true);
var state := PARSEJSON(Cover.GetStatus, "$.state", true);
var date := NOW();

if ISNULL(slatPos)
    adderror("Slat position must be enabled for blinds");
    return(NaN);
end

if state = "closing" or state = "opening"
	BsSend := 1;
	return(Bs);
end

if BsSend > 1
	BsSend := 1;
	return(Bs);
else
	if BsSend = 1
		BsSend := 0;
		DeltaPos := pos - round(linear(Bl,0,100,1,0));	
	end
	return(linear(slatPos,0,1,100,0));
end
```

Zapis nachylenia lameli

```taphome
var date := NOW();
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);

if BlSend = 0
	VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=0&pos=" + pos + "&slat_pos=" + round(linear(Bs,0,100,1,0)));
	BsSend := date.UNIXTIME;
	IF response.IsSuccess = false
	  ADDERROR(response.StatusCode);
	END
end

#response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=0");
#IF response.IsSuccess
#    Cover.GetStatus := response.Content;  
#END
```

Atrybuty serwisowe

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Cover.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Cover.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Cover.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Cover.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Cover.GetStatus, "$.current", true)
```

Slat

```taphome
if(parsejson(Cover.GetConfig, "$.slat.enable", true), "Enabled", "Disabled")
```

Slat open time \[s]

```taphome
parsejson(Cover.GetConfig, "$.slat.open_time ", true)
```

Slat close time \[s]

```taphome
parsejson(Cover.GetConfig, "$.slat.open_time ", true)
```

Akcje serwisowe

${start\_automatic\_calibration}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Cover.Calibrate?id=" + ID);
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Set Slat

Parametry: Open time \[s] (0.1–5 ot), Close time \[s] (0.1–5 ct)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Cover.SetConfig?id=" + ID + 
	"&config={\"slat\":{\"enable\":true, \"open_time\": " + ot +", \"close_time\": " + ct +"}}");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

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

Możliwe ulepszenia (11)

- Input 1 State — Physical switch/button input 1 state, available via /rpc/Input.GetStatus?id=0
- Input 2 State — Physical switch/button input 2 state, available via /rpc/Input.GetStatus?id=1
- Returned Energy — Returned/exported energy in Wh, for bi-directional metering scenarios
- Uptime — Seconds since last reboot, available in Sys.GetStatus response
- RAM Usage — Total and free RAM in bytes, available in Sys.GetStatus response
- Device Time — Current device time in HH:MM format, available in Sys.GetStatus response
- Auto-off Timer — Auto-reset timer in seconds via toggle\_after parameter, could be added as switch parameter
- Reset Energy Counters — Resets energy measurement counters (aenergy, ret\_aenergy) for both channels
- Overpower Protection — Configurable power limit threshold in Watts, relay turns off when exceeded
- Cover State — Cover movement state (open/opening/closed/closing/stopped/calibrating), available in Cover.GetStatus
- Cover Open/Close/Stop Commands — Direct open/close/stop commands without position parameter; template uses GoToPosition instead

## Parametry importu

Te wartości podajesz podczas importu pliku XML.

| Pytanie w aplikacji | Domyślnie     |
|---------------------|---------------|
| Adres IP            | `192.168.0.1` |

## Źródła

- Shelly Gen2+/Gen3 RPC API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/) 2026-03-27
- Shelly Gen2+ Switch Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-27
- Shelly Gen2+ System (Sys) Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-27
- Shelly Gen2+ WiFi Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/WiFi/) 2026-03-27
- Home Assistant Shelly Integration
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-27
- Shelly 2PM Gen3 Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-2pm-gen3) 2026-03-29

## 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/)