---
title: "Przykłady skryptów"
description: "Gotowe przykłady skryptów TapHome: bezpieczne dzielenie va1/va2, zapis 0 zamiast NaN, ściemnianie przez LINEAR, bity alarmów Modbus, atrybuty serwisowe, HTTP + JSON, listener MQTT, Wake on LAN."
url: "https://taphome.com/pl/docs/script/examples/"
language: pl
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["scripting-language","script-examples","smart-rules","modbus","packet-parser"]
  questions: ["Jak bezpiecznie podzielić dwie zmienne (va1/va2) w skrypcie TapHome?","Jak naprawić błąd „Line in script: 1 Message: Division by zero”?","Jak zapisać wartość 0, gdy urządzenie jest w błędzie lub zwraca NaN?","Jak użyć LINEAR do ściemniania — przeliczenia wartości na jasność światła?","Jak zgłaszać błędy urządzenia z rejestru alarmów Modbus?","Jak zamienić liczbowy kod statusu na tekst w skrypcie TapHome?","Jak wysłać żądanie HTTP i obsłużyć nieudaną odpowiedź w skrypcie Packet parser?","Jak przejść pętlą po tablicy JSON w skrypcie TapHome?","Jak wysłać pakiet Wake on LAN z TapHome?"]
---

# Przykłady skryptów

Kompletne skrypty TapHome: bezpieczne dzielenie, 0 zamiast nieznanej wartości, ściemnianie przez LINEAR, alarmy Modbus i atrybuty serwisowe, HTTP i JSON, listener MQTT i Wake on LAN.

Ostatnia aktualizacja: 2026-11-06

Kompletne skrypty do częstych zadań. Gotowe rozwiązania dla smart rules działają w każdej instalacji; przykłady Modbus i Packet parser pochodzą z oficjalnych repozytoriów szablonów dla [Modbus](https://github.com/taphome-official/modbus_templates) i [Packet parser](https://github.com/taphome-official/packetparser_templates). Krótkie nazwy, takie jak `Se`, `va1` czy `St`, to skróty wartości urządzeń wybranych w edytorze skryptu; nazwy takie jak `StatusJson` czy `plugTopic` to zmienne modułu.

## Gotowe rozwiązania dla smart rules

### Bezpieczne dzielenie dwóch wartości

Dzielenie przez wartość urządzenia równą 0 zatrzymuje skrypt błędem `Line in script: 1 Message: Division by zero`. Obejmij dzielenie `va1/va2` funkcyjną formą `IF`. Oblicza ona tylko wybraną gałąź, więc dzielenie wykona się tylko wtedy, gdy dzielnik jest większy od 0. W skrypcie smart rule na przykład dla `va1 = 10` i `va2 = 4` wynik to `2.5`, a dla `va2 = 0` wynik to `0`:

```taphome
IF(va2 > 0, va1/va2, 0);
# Result: 0 when va2 is 0, otherwise va1 divided by va2
```

Gdy dzielnik może być ujemny, sprawdzaj zamiast tego `va2 <> 0`. Więcej w [Błędy](https://taphome.com/pl/docs/script/errors/#division-by-zero).

### Zapis 0 zamiast nieznanej wartości

Nieznana wartość urządzenia, na przykład z czujnika w błędzie, to `NaN`. Aby zamiast niej zapisać `0`, sprawdź ją przez `ISNAN` — wzorzec to `IF(ISNAN(x), 0, x)`. W skrypcie smart rule na przykład dla `Se = 21.5` wynik to `21.5`, a dla nieznanej wartości `Se` (`NaN`) wynik to `0`:

```taphome
IF(ISNAN(Se), 0, Se);
# Result: 0 while the value of Se is unknown, otherwise the value of Se
```

Porównanie takie jak `Se = NaN` to błąd parsowania. Gdy wartość może być także `Null` (brak wartości), najpierw sprawdź `ISNULL`; `OR` pomija swoją prawą stronę, gdy lewa strona jest `TRUE`. W skrypcie smart rule na przykład dla `Se = 21.5` wynik to `21.5`, a dla `Se` bez wartości (`Null`) wynik to `0`:

```taphome
IF(ISNULL(Se) OR ISNAN(Se), 0, Se);
```

### Ściemnianie przez LINEAR

`LINEAR` przenosi zakres wartości wejściowych na zakres wartości wyjściowych, co jest zwykłym sposobem obliczania poziomu ściemnienia. Poziom ściemniacza idzie od 0 (wyłączony) do 1 (100 %). W smart rule Formuła ze ściemniaczem jako wyjściem ten skrypt ściemnia światło, gdy światło dzienne rośnie od 0 do 500 lx (`Se` to czujnik oświetlenia). Na przykład dla `Se = 250` lx poziom ściemniacza wynosi `0.5`:

```taphome
LINEAR(Se, 0, 1, 500, 0);
# Result: 1 at 0 lx, 0.5 at 250 lx, 0 at 500 lx and more
```

Poza zakresem wejściowym wynik zostaje na najbliższym końcu (`BOUNDS`, domyślnie). Aby zachować minimalny poziom, podnieś dolne wyjście: `LINEAR(Se, 0, 1, 500, 0.1)` nigdy nie spada poniżej 10 %. Szczegóły w [LINEAR](https://taphome.com/pl/docs/script/interpolation-and-thresholds/#linear).

## Przykłady Modbus

### Błędy urządzenia z rejestru alarmów

Skrypt odczytu falownika solarnego Solax zamienia rejestr statusu i 32-bitowe słowo alarmów na błędy urządzenia. Na przykład rejestr pod adresem `0x09` o wartości `3` i słowo alarmów pod adresem `0x0040` o wartości `4` (ustawiony bit 2) zgłaszają błędy Run Mode Fault i Grid Volt Fault:

```taphome
# rejestr statusu: błąd dla wartości 3 lub 4
VAR reg := MODBUSR(A, 0x09, UInt16);
IF(reg = 3, ADDERROR("Run Mode Fault"));
IF(reg = 4, ADDERROR("Run Mode Permanent Fault"));

# 32-bitowe słowo alarmów: jeden błąd na ustawiony bit
VAR x3 := MODBUSR(A, 0x0040, Uint32);
IF(GETBIT(x3, 0) = 1, ADDERROR("TZ Protect Fault"));
IF(GETBIT(x3, 1) = 1, ADDERROR("Grid Lost Fault"));
IF(GETBIT(x3, 2) = 1, ADDERROR("Grid Volt Fault"));
IF(GETBIT(x3, 15) = 1, ADDERROR("Off-grid Overload"));
```

### Atrybut serwisowy z pól bitowych

Atrybut serwisowy Komfovent wyświetla cztery bajty 32-bitowego rejestru jako tekst z kropkami. Na przykład wartość rejestru `16909060` daje tekst `1.2.3.4`:

```taphome
# odczyt 32-bitowego rejestru
VAR reg := MODBUSR(H, 22, Uint32);
# podział na cztery bajty
VAR first := GETBITS(reg, 0, 8);
VAR second := GETBITS(reg, 8, 8);
VAR third := GETBITS(reg, 16, 8);
VAR last := GETBITS(reg, 24, 8);
# łączenie bajtów kropkami, ostatni bajt pierwszy
RETURN(last + "." + third + "." + second + "." + first);
# Result: text such as "1.2.3.4"
```

### Akcja serwisowa z parametrem

Parametry akcji serwisowej to zmienne nazwane według ich skrótu. Akcja Eastron SDM120 zapisuje swój parametr `ID` do holding register 20. Na przykład dla `ID = 5` akcja zapisuje wartość `5`:

```taphome
MODBUSW(H, 20, Float, ID)
```

### Odczytanie wyliczenia

Rejestr statusu Huawei SUN2000 staje się czytelnym tekstem dzięki `SWITCH`. Na przykład wartość rejestru statusu `512` daje tekst On-Grid:

```taphome
# odczyt rejestru statusu
VAR state := MODBUSR(H, 32089, Uint16);
# kod zamieniany na tekst; ostatni wiersz to wartość zapasowa
SWITCH(state,
      0, "Idle: Initializing",
      1, "Idle: Detecting ISO",
    256, "Starting",
    512, "On-Grid",
    768, "Shutdown: Fault",
    "Unknown");
```

## Przykłady Packet parser

### Żądanie HTTP z obsługą błędów

`SENDHTTPREQUEST` zwraca obiekt `httpresponse`. Ten skrypt odczytu (Forecast.solar) zachowuje treść odpowiedzi w zmiennej `output` do późniejszego parsowania, a nieudane żądanie zgłasza jako błąd urządzenia. Na przykład dla `Latitude = 48.1778`, `Longitude = 17.1426`, `PV_declination = 45`, `PV_azimuth = 0` i `PV_kWp = 5` wysyła żądanie `/estimate/48.1778/17.1426/45/0/5`:

```taphome
# żądanie prognozy ze zmiennych modułu
VAR response := SENDHTTPREQUEST("/estimate/" + Latitude + "/" + Longitude + "/"
    + PV_declination + "/" + PV_azimuth + "/" + PV_kWp,
    "GET", "", "Accept: application/json");

# zapis treści odpowiedzi lub zgłoszenie błędu żądania
IF response.IsSuccess
    output := response.Content;
ELSE
    ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
END
```

### Czas pracy z JSON

Atrybut serwisowy Shelly 1PM formatuje czas pracy w sekundach z zapamiętanego JSON statusu. Na przykład JSON statusu `{"uptime":191820}` daje `2 day(s) 5h 17m`:

```taphome
# czas pracy w sekundach z JSON statusu
VAR upTimeSeconds := PARSEJSON(StatusJson, "uptime");
# podział sekund na dni, godziny i minuty
VAR days := FLOOR(upTimeSeconds / 86400, 1);
upTimeSeconds := MOD(upTimeSeconds, 86400);
VAR hours := FLOOR(upTimeSeconds / 3600, 1);
upTimeSeconds := MOD(upTimeSeconds, 3600);
VAR minutes := FLOOR(upTimeSeconds / 60, 1);
# zwrot sformatowanego tekstu
days + " day(s) " + hours + "h " + minutes + "m";
# Result: for 191820 seconds "2 day(s) 5h 17m"
```

### Cena spot dla bieżącego okresu

Skrypt odczytu pobiera dzisiejsze ceny z okte.sk. Na przykład dnia `2026-03-28` wysyła żądanie `/api/v1/dam/results?deliveryDayFrom=2026-03-28&deliveryDayTo=2026-03-28`:

```taphome
# dzisiejsza data jako tekst
VAR today := TOSTRING(NOW(), "yyyy-MM-dd");
# żądanie dzisiejszych cen
VAR response := SENDHTTPREQUEST("/api/v1/dam/results?deliveryDayFrom=" + today
    + "&deliveryDayTo=" + today);

# zapis treści odpowiedzi lub zgłoszenie błędu żądania
IF response.IsSuccess
    output := response.Content;
ELSE
    ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
END
```

Atrybut serwisowy wybiera następnie jeden okres filtrem JSONPath. Na przykład z odpowiedzi `[{"period":1,"price":112.5},{"period":2,"price":108.2}]` zwraca `112.5 EUR`:

```taphome
PARSEJSON(output, "$[?(@.period == 1)].price") + " EUR"
```

### Pętla po tablicy JSON

Z `TRUE` jako trzecim argumentem `PARSEJSON` zwraca `Null` po ostatnim elemencie zamiast błędu, co kończy pętlę. W atrybucie serwisowym Devices modułu TapHome API na przykład odpowiedź `{"devices":[{"deviceId":5,"name":"Lamp","type":"Dimmer"}]}` daje tekst `(5) Lamp - Dimmer`:

```taphome
# żądanie listy urządzeń
VAR response := SENDHTTPREQUEST("/api/taphomeapi/v1/discovery", "GET", "",
    "Authorization: TapHome " + API_token);

IF response.IsSuccess
    # start od pierwszego urządzenia
    VAR ret := "";
    VAR i := 0;
    VAR id := PARSEJSON(response.Content, "$.devices[0].deviceId", TRUE);

    WHILE !ISNULL(id)
        # dopisanie id, nazwy i typu urządzenia do tekstu
        ret := ret + "(" + id + ") ";
        ret := ret + PARSEJSON(response.Content, "$.devices[" + TOSTRING(i) + "].name", TRUE);
        ret := ret + " - " + PARSEJSON(response.Content, "$.devices[" + TOSTRING(i) + "].type", TRUE);
        ret := ret + "\n";
        # przejście do następnego urządzenia
        i := i + 1;
        id := PARSEJSON(response.Content, "$.devices[" + TOSTRING(i) + "].deviceId", TRUE);
    LOOP

    RETURN(ret);
END
```

### Sprawdzenie zmiennej modułu w skrypcie listener

Skrypt listener MQTT Shelly najpierw sprawdza, czy zmienna modułu `plugTopic` została wypełniona, a potem przelicza odczyt mocy z W na kW. Na przykład dla `plugTopic = shelly1pm-ABC123` wiadomość w temacie `shellies/shelly1pm-ABC123/relay/0/power` z treścią `42.5` ustawia `Ed` na `0.0425`:

```taphome
# sprawdzenie zmiennej modułu plugTopic
IF(INDEXOF(plugTopic, "shelly1pm-deviceid") = 0)
    ADDERROR("Set correct 'plugTopic' value in module variables. "
        + "Topic format is 'shelly1pm-<deviceid>'.");
    RETURN(-1);
END

# reakcja tylko na wiadomość o mocy tego urządzenia
IF(RECEIVEDMSG.TOPIC = "shellies/" + plugTopic + "/relay/0/power")
    VAR valueP := TOSTRING(RECEIVEDMSG.PAYLOAD);
    # przeliczenie z W na kW
    Ed := IF(ISNULL(valueP), NaN, TODOUBLE(valueP) / 1000.0);
END
```

### Wake on LAN

Przycisk UDP wysyła magiczny pakiet. Zmienna modułu `MAC` przechowuje adres jako tekst (`"12 34 56 78 9a bc"`); `BYTECOLLECTION` ignoruje spacje. W module Wake on LAN na przykład `MAC = 12 34 56 78 9a bc` daje sześć bajtów `FF`, a po nich 16 kopii tego adresu:

```taphome
VAR magicPacket := BYTECOLLECTION("FF FF FF FF FF FF " + MAC + MAC + MAC + MAC
    + MAC + MAC + MAC + MAC + MAC + MAC + MAC + MAC + MAC + MAC + MAC + MAC);
SENDDATA(magicPacket);
```
