---
title: "Szkriptpéldák"
description: "Használatra kész TapHome szkriptpéldák: biztonságos va1/va2 osztás, 0 írása NaN helyett, LINEAR fényerő-szabályozás, Modbus riasztási bitek, szolgáltatási attribútumok, HTTP + JSON, MQTT listener, Wake on LAN."
url: "https://taphome.com/hu/docs/script/examples/"
language: hu
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["scripting-language","script-examples","smart-rules","modbus","packet-parser"]
  questions: ["Hogyan oszthatok el két változót (va1/va2) biztonságosan egy TapHome szkriptben?","Hogyan javíthatom a \"Line in script: 1 Message: Division by zero\" hibát?","Hogyan írhatok 0 értéket, ha egy eszköz hibás vagy NaN értéket ad vissza?","Hogyan használhatom a LINEAR függvényt fényerő-szabályozásra — egy érték leképezésére a lámpa fényerejére?","Hogyan jelezhetek eszközhibákat egy Modbus riasztási regiszterből?","Hogyan alakíthatok át egy numerikus állapotkódot szöveggé egy TapHome szkriptben?","Hogyan küldhetek HTTP-kérést, és hogyan kezelhetem a sikertelen választ egy Packet parser szkriptben?","Hogyan járhatok be egy JSON tömböt ciklussal egy TapHome szkriptben?","Hogyan küldhetek Wake on LAN csomagot a TapHome-ból?"]
---

# Szkriptpéldák

Teljes TapHome szkriptek: biztonságos osztás, 0 ismeretlen érték helyett, fényerő-szabályozás LINEAR-ral, Modbus riasztások és szolgáltatási attribútumok, HTTP és JSON, MQTT listener és Wake on LAN.

Utoljára frissítve: 2026-11-06

Teljes szkriptek gyakori feladatokhoz. A smart rule receptek bármely telepítésben működnek; a Modbus és Packet parser példák a hivatalos [Modbus](https://github.com/taphome-official/modbus_templates) és [Packet parser](https://github.com/taphome-official/packetparser_templates) sablontárakból származnak. Az olyan rövid nevek, mint a `Se`, a `va1` vagy az `St`, a szkriptszerkesztőben kiválasztott eszközértékek rövidítései; az olyan nevek, mint a `StatusJson` vagy a `plugTopic`, modulváltozók.

## Smart rule receptek

### Két érték biztonságos osztása

A 0 értékű eszközértékkel való osztás a `Line in script: 1 Message: Division by zero` hibával leállítja a szkriptet. Foglald a `va1/va2` osztást az `IF` függvényalakjába. Ez csak a kiválasztott ágat értékeli ki, így az osztás csak akkor fut le, ha az osztó nagyobb 0-nál. Egy smart rule szkriptben például `va1 = 10` és `va2 = 4` esetén az eredmény `2.5`, `va2 = 0` esetén pedig `0`:

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

Ha az osztó negatív is lehet, inkább a `va2 <> 0` feltételt vizsgáld. Bővebben a [Hibák](https://taphome.com/hu/docs/script/errors/#division-by-zero) oldalon.

### 0 írása ismeretlen érték helyett

Az ismeretlen eszközérték, például egy hibás érzékelőé, `NaN`. Ha helyette `0` értéket szeretnél írni, vizsgáld az `ISNAN` függvénnyel — a minta `IF(ISNAN(x), 0, x)`. Egy smart rule szkriptben például `Se = 21.5` esetén az eredmény `21.5`, ismeretlen `Se` (`NaN`) esetén pedig `0`:

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

Az olyan összehasonlítás, mint a `Se = NaN`, elemzési hiba. Ha az érték `Null` (nincs érték) is lehet, előbb az `ISNULL` függvénnyel vizsgáld; az `OR` kihagyja a jobb oldalát, ha a bal oldala `TRUE`. Egy smart rule szkriptben például `Se = 21.5` esetén az eredmény `21.5`, érték nélküli `Se` (`Null`) esetén pedig `0`:

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

### Fényerő-szabályozás LINEAR-ral

A `LINEAR` a bemeneti értékek egy tartományát kimeneti értékek tartományára képezi le, ez a fényerőszint kiszámításának szokásos módja. A dimmer szintje 0-tól (kikapcsolva) 1-ig (100 %) terjed. Egy dimmert kimenetként használó Képlet smart rule-ban ez a szkript csökkenti a lámpa fényerejét, ahogy a nappali fény 0-ról 500 lx-ra nő (`Se` a fényérzékelő). Például `Se = 250` lx esetén a dimmer szintje `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
```

A bemeneti tartományon kívül az eredmény a legközelebbi végponton marad (`BOUNDS`, az alapértelmezés). Minimális szint megtartásához emeld meg az alsó kimenetet: a `LINEAR(Se, 0, 1, 500, 0.1)` soha nem megy 10 % alá. Részletek a [LINEAR](https://taphome.com/hu/docs/script/interpolation-and-thresholds/#linear) részben.

## Modbus példák

### Eszközhibák riasztási regiszterből

Egy Solax napelem inverter olvasó szkriptje egy állapotregisztert és egy 32 bites riasztási szót eszközhibákká alakít. Például a `0x09` címen lévő, `3` értékű regiszter és a `0x0040` címen lévő, `4` értékű riasztási szó (a 2. bit be van állítva) a Run Mode Fault és a Grid Volt Fault hibát váltja ki:

```taphome
# állapotregiszter: hiba 3 vagy 4 értéknél
VAR reg := MODBUSR(A, 0x09, UInt16);
IF(reg = 3, ADDERROR("Run Mode Fault"));
IF(reg = 4, ADDERROR("Run Mode Permanent Fault"));

# 32 bites riasztási szó: egy hiba beállított bitenként
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"));
```

### Szolgáltatási attribútum bitmezőkből

Egy Komfovent szolgáltatási attribútum egy 32 bites regiszter négy bájtját pontokkal elválasztott szövegként jeleníti meg. Például a `16909060` regiszterérték az `1.2.3.4` szöveget adja:

```taphome
# a 32 bites regiszter beolvasása
VAR reg := MODBUSR(H, 22, Uint32);
# felbontás négy bájtra
VAR first := GETBITS(reg, 0, 8);
VAR second := GETBITS(reg, 8, 8);
VAR third := GETBITS(reg, 16, 8);
VAR last := GETBITS(reg, 24, 8);
# bájtok összefűzése pontokkal, az utolsó bájt elöl
RETURN(last + "." + third + "." + second + "." + first);
# Result: text such as "1.2.3.4"
```

### Szolgáltatási művelet paraméterrel

A szolgáltatási művelet paraméterei a rövidítésükről elnevezett változók. Egy Eastron SDM120 művelet az `ID` paraméterét a 20-as holding regiszterbe írja. Például `ID = 5` esetén a művelet az `5` értéket írja:

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

### Felsorolás dekódolása

Egy Huawei SUN2000 állapotregiszterből a `SWITCH` függvénnyel lesz olvasható szöveg. Például az `512` állapotregiszter-érték az On-Grid szöveget adja:

```taphome
# az állapotregiszter beolvasása
VAR state := MODBUSR(H, 32089, Uint16);
# a kód szöveggé alakítása; az utolsó sor a tartalék érték
SWITCH(state,
      0, "Idle: Initializing",
      1, "Idle: Detecting ISO",
    256, "Starting",
    512, "On-Grid",
    768, "Shutdown: Fault",
    "Unknown");
```

## Packet parser példák

### HTTP-kérés hibakezeléssel

A `SENDHTTPREQUEST` egy `httpresponse` objektumot ad vissza. Ez az olvasó szkript (Forecast.solar) a válasz törzsét az `output` változóban tárolja a későbbi elemzéshez, a sikertelen kérést pedig eszközhibaként jelzi. Például `Latitude = 48.1778`, `Longitude = 17.1426`, `PV_declination = 45`, `PV_azimuth = 0` és `PV_kWp = 5` esetén a `/estimate/48.1778/17.1426/45/0/5` címet kéri le:

```taphome
# az előrejelzés lekérése a modulváltozókból
VAR response := SENDHTTPREQUEST("/estimate/" + Latitude + "/" + Longitude + "/"
    + PV_declination + "/" + PV_azimuth + "/" + PV_kWp,
    "GET", "", "Accept: application/json");

# a válasz törzsének mentése vagy a kérés hibájának jelzése
IF response.IsSuccess
    output := response.Content;
ELSE
    ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
END
```

### Üzemidő JSON-ból

Egy Shelly 1PM szolgáltatási attribútum a gyorsítótárban tárolt állapot-JSON-ból formázza meg a másodpercben megadott üzemidőt. Például a `{"uptime":191820}` állapot-JSON `2 day(s) 5h 17m` szöveget ad:

```taphome
# üzemidő másodpercben az állapot-JSON-ból
VAR upTimeSeconds := PARSEJSON(StatusJson, "uptime");
# a másodpercek felbontása napokra, órákra, percekre
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);
# a formázott szöveg visszaadása
days + " day(s) " + hours + "h " + minutes + "m";
# Result: for 191820 seconds "2 day(s) 5h 17m"
```

### Spot ár az aktuális időszakra

Egy olvasó szkript letölti a mai árakat az okte.sk oldalról. Például `2026-03-28` napon a `/api/v1/dam/results?deliveryDayFrom=2026-03-28&deliveryDayTo=2026-03-28` címet kéri le:

```taphome
# a mai dátum szövegként
VAR today := TOSTRING(NOW(), "yyyy-MM-dd");
# a mai árak lekérése
VAR response := SENDHTTPREQUEST("/api/v1/dam/results?deliveryDayFrom=" + today
    + "&deliveryDayTo=" + today);

# a válasz törzsének mentése vagy a kérés hibájának jelzése
IF response.IsSuccess
    output := response.Content;
ELSE
    ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
END
```

Ezután egy szolgáltatási attribútum JSONPath szűrővel kiválaszt egy időszakot. Például a `[{"period":1,"price":112.5},{"period":2,"price":108.2}]` válaszból `112.5 EUR` értéket ad vissza:

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

### Ciklus JSON tömbön

Harmadik argumentumként `TRUE` értékkel a `PARSEJSON` az utolsó elem után hiba helyett `Null` értéket ad vissza, ami befejezi a ciklust. A TapHome API modul Devices szolgáltatási attribútumában például a `{"devices":[{"deviceId":5,"name":"Lamp","type":"Dimmer"}]}` válasz a `(5) Lamp - Dimmer` szöveget adja:

```taphome
# az eszközlista lekérése
VAR response := SENDHTTPREQUEST("/api/taphomeapi/v1/discovery", "GET", "",
    "Authorization: TapHome " + API_token);

IF response.IsSuccess
    # indulás az első eszközzel
    VAR ret := "";
    VAR i := 0;
    VAR id := PARSEJSON(response.Content, "$.devices[0].deviceId", TRUE);

    WHILE !ISNULL(id)
        # az eszköz azonosítójának, nevének és típusának hozzáfűzése
        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";
        # továbblépés a következő eszközre
        i := i + 1;
        id := PARSEJSON(response.Content, "$.devices[" + TOSTRING(i) + "].deviceId", TRUE);
    LOOP

    RETURN(ret);
END
```

### Modulváltozó ellenőrzése listener szkriptben

Egy Shelly MQTT listener szkript először ellenőrzi, hogy a `plugTopic` modulváltozó ki van-e töltve, majd a teljesítményértéket W-ból kW-ba alakítja. Például `plugTopic = shelly1pm-ABC123` esetén a `shellies/shelly1pm-ABC123/relay/0/power` témára érkező, `42.5` tartalmú üzenet az `Ed` értékét `0.0425` értékre állítja:

```taphome
# a plugTopic modulváltozó ellenőrzése
IF(INDEXOF(plugTopic, "shelly1pm-deviceid") = 0)
    ADDERROR("Set correct 'plugTopic' value in module variables. "
        + "Topic format is 'shelly1pm-<deviceid>'.");
    RETURN(-1);
END

# reagálás csak ennek az eszköznek a teljesítményüzenetére
IF(RECEIVEDMSG.TOPIC = "shellies/" + plugTopic + "/relay/0/power")
    VAR valueP := TOSTRING(RECEIVEDMSG.PAYLOAD);
    # átváltás W-ról kW-ra
    Ed := IF(ISNULL(valueP), NaN, TODOUBLE(valueP) / 1000.0);
END
```

### Wake on LAN

Egy UDP nyomógomb magic packetet küld. A `MAC` modulváltozó szövegként tárolja a címet (`"12 34 56 78 9a bc"`); a `BYTECOLLECTION` figyelmen kívül hagyja a szóközöket. A Wake on LAN modulban például `MAC = 12 34 56 78 9a bc` hat `FF` bájtot ad, majd ennek a címnek 16 másolatát:

```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);
```
