---
title: "Bitműveletek"
description: "TapHome szkript bitműveletek: GETBIT, GETBITS, GETBYTE, SETBYTE, SETBIT, SETBITS, BCD-átalakítás, 8/16/32/64 bites szélesség, bitléptetés, bitenkénti ÉS és VAGY Excel megfelelőkkel."
url: "https://taphome.com/hu/docs/script/bit-operations/"
language: hu
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["bit-operations","byte-manipulation","bitwise-operators","scripting-language"]
  questions: ["Hogyan olvashatok ki egyetlen bitet egy számból a TapHome-ban?","Hogyan nyerhetek ki egy bájtot egy számból a GETBYTE függvénnyel?","Hogyan állíthatok be egy adott bitet vagy bájtot egy TapHome szkriptben?","Hogyan végezhetek bitléptetést balra vagy jobbra a TapHome-ban?","Hogyan működik a bitenkénti ÉS és VAGY a TapHome szkriptekben?","Mik a TapHome bitoperátorainak Excel megfelelői?","Hány bitet használnak a bitfüggvények egy 16 vagy 64 bites értéknél?","Hogyan alakíthatok át egy számot BCD formátumra vagy BCD formátumból?"]
---

# Bitműveletek

Bitek és bájtok kezelése a TapHome szkriptben — GETBIT, GETBITS, SETBIT, SETBITS, GETBYTE, SETBYTE, TOBCD, FROMBCD, bitszélesség típus szerint és bitenkénti operátorok Excel megfelelőkkel.

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

Ezek a függvények egy egész szám egyes bitjeit, bitmezőit és bájtjait olvassák és módosítják — jellemzően a `MODBUSR` függvénnyel olvasott állapotszavakat és riasztási regisztereket. A 0. bit a legkisebb helyiértékű (jobb szélső) bit, a 0. bájt a legkisebb helyiértékű bájt.

## Bitszélesség típus szerint

Hogy egy szám hány bitből áll a bitfüggvények számára, az a típusától függ:

| A `number` típusa | Bitek | `bit` / `startBit` | Bájt `index` | A `GETBITS`, `SETBIT`, `SETBITS`, `SETBYTE` eredménye |
|---|---|---|---|---|
| `int8`, `uint8` | 8 | 0 – 7 | 0 | `uint` |
| `int16`, `uint16` | 16 | 0 – 15 | 0 – 1 | `uint` |
| `int64`, `uint64` | 64 | 0 – 63 | 0 – 7 | `uint64` |
| minden más (`double`, `float`, `int`, `uint`, …) | 32 | 0 – 31 | 0 – 3 | `uint` |

- A `MODBUSR`, a tizedes literálok, a `PARSEJSON` és az eszközök értékei `double` típusúak, ezért 32 bitesnek számítanak. Más szélessége csak a típusos változóknak, a gyűjtemények elemeinek és a 64 bites Modbus adattípusoknak van.
- A típuson kívül eső bit vagy bájt hibát okoz, például a `GETBIT(x, 16)` egy `uint16` változónál: *GETBIT - bit must be between 0 and 15*. Az a bitmező, amely a típuson belül **kezdődik**, de túlnyúlik a tetején, megengedett — a `GETBITS` a létező biteket adja vissza, a `SETBITS` a többit elhagyja.
- A `double` vagy `float` egész számra kerekítődik, és −2 147 483 648 és 4 294 967 295 között kell lennie; minden más, a `NaN` is, hibát okoz (*value X is out of the 32-bit range*). A negatív értékek kettes komplemenst használnak, ezért a `GETBITS(-1, 0, 16)` értéke `65535`.

**Elérhetőség** — a típus szerinti szélességhez szükséges verzió: TapHome Next 2026.1.40665+. A régebbi buildek minden értéket 32 bitesnek tekintenek: a 64 bites érték elveszíti a felső felét, a 8 vagy 16 bites típus feletti bit pedig `0` értéket ad.

## GETBIT

A `GETBIT` egy szám egyetlen bitjének értékét adja vissza, `0` vagy `1`.

```text
GETBIT(number, bit)
```

**Példa**

```taphome
# egy szám egyetlen bitjét olvassa
GETBIT(2, 0);
# Result: 0
GETBIT(4, 2);
# Result: 1
# 3-as hibát jelez, ha a regiszter 3. bitje be van állítva
IF(GETBIT(MODBUSR(H, 600, Uint16), 3) = 1, ADDERROR(3, "Overheating"));
```

## GETBITS

A `GETBITS` egy bitmezőt — a `startBit` bittől kezdődő `numberOfBits` bitet — ad vissza előjel nélküli egész számként.

```text
GETBITS(number, startBit, numberOfBits)
```

**Paraméterek** — a `numberOfBits` értéke 1 – 32, 64 bites `number` esetén 1 – 64.

**Példa**

```taphome
GETBITS(216, 3, 2);
# Result: 3 (216 = 0b11011000, bits 3 and 4 are 1)
GETBITS(0xFF, 0, 4);
# Result: 15
```

Regiszterenként két bájtba csomagolt dátum és idő (Komfovent):

```taphome
VAR time := MODBUSR(H, 28, Uint16);
VAR date := MODBUSR(H, 30, Uint16);
GETBITS(time, 8, 8) + ":" + GETBITS(time, 0, 8) + " "
    + GETBITS(date, 0, 8) + "." + GETBITS(date, 8, 8) + "." + MODBUSR(H, 29, Uint16);
```

## SETBIT

A `SETBIT` a számot úgy adja vissza, hogy egyik bitje 0 (ha a `value` 0) vagy 1 (bármely más `value` esetén).

```text
SETBIT(number, bit, value)
```

**Példa**

```taphome
# az 1 szám 1. bitjét 1-re, a 4 szám 2. bitjét 0-ra állítja
SETBIT(1, 1, 1);
# Result: 3
SETBIT(4, 2, 0);
# Result: 0
# egy 64 bites változó 40. bitjét beállítja és visszaolvassa
uint64 alarms := 0;
alarms := SETBIT(alarms, 40, 1);
GETBIT(alarms, 40);
# Result: 1 (a 64-bit variable has bits 0 to 63)
```

## SETBITS

A `SETBITS` a számot úgy adja vissza, hogy a `startBit` bittől kezdődő, `numberOfBits` bit hosszú bitmezőt a `value` értékre cseréli.

```text
SETBITS(number, startBit, numberOfBits, value)
```

**Példa**

```taphome
SETBITS(192, 4, 2, 3);
# Result: 240
SETBITS(192, 5, 2, 3);
# Result: 224
```

**Hibák** — *Given number of bits (2) is not enought for storing the value 4.*, ha a `value` nem fér bele a mezőbe (az üzenet valóban így van írva).

## GETBYTE

A `GETBYTE` egy szám egyik bájtját (0 – 255) adja vissza `uint` típusként.

```text
GETBYTE(number, index)
```

**Példa**

```taphome
# a 0. index a legalacsonyabb bájt, az 1. index a következő
GETBYTE(256, 0);
# Result: 0
GETBYTE(256, 1);
# Result: 1
# 259 = 0x0103, ezért a 0. bájt értéke 3
GETBYTE(259, 0);
# Result: 3
```

## SETBYTE

A `SETBYTE` a számot úgy adja vissza, hogy az `index` helyen álló bájtot a `value` értékre (0 – 255) cseréli.

```text
SETBYTE(number, index, value)
```

**Példa**

```taphome
SETBYTE(256, 0, 255);
# Result: 511
SETBYTE(259, 1, 2);
# Result: 515
```

**Hibák** — *Given value (X) is bigger than maximum byte value.*; *Given value is less than 0.*

## TOBCD

A `TOBCD` egy egész számot tömörített BCD formátumra alakít — minden tízes számrendszerbeli számjegy saját 4 bitet kap —, és `uint` típusként adja vissza; legfeljebb 8 számjegyet őriz meg.

```text
TOBCD(number)
```

**Példa**

```taphome
TOBCD(1234);
# Result: 4660 (0x1234)
```

## FROMBCD

A `FROMBCD` egy tömörített BCD értéket alakít vissza közönséges számmá.

```text
FROMBCD(number)
```

**Példa**

```taphome
FROMBCD(0x1234);
# Result: 1234
```

**Hibák** — *FROMBCD - number 26 is not in BCD format* és a számjegy pozíciója, ha egy 4 bites csoport értéke nagyobb 9-nél (itt `0x1A`).

## Bitenkénti operátorok és Excel megfelelők

Az operátorok egész számokkal dolgoznak; a `double` operandus előbb `int64` típusra alakul, a `Null` operandus pedig `Null` eredményt ad. A teljes lista és a precedencia az [Operátorok](https://taphome.com/hu/docs/script/operators/) oldalon található.

| Operátor | Példa | Eredmény | Excel |
|---|---|---|---|
| `<<` bitléptetés balra | `8 << 2` | `32` | `BITLSHIFT(number, shift_amount)` |
| `>>` bitléptetés jobbra | `32 >> 2` | `8` | `BITRSHIFT(number, shift_amount)` |
| `&` bitenkénti ÉS | `3 & 1` | `1` | `BITAND(number1, number2)` |
| `\|` bitenkénti VAGY | `2 \| 1` | `3` | `BITOR(number1, number2)` |
| `^` bitenkénti XOR | `5 ^ 1` | `4` | `BITXOR(number1, number2)` |

> [!WARNING]
> A bitenkénti operátorok gyengébben kötnek, mint az összehasonlítások: az `a & 1 > 0` jelentése `a & (1 > 0)`. Mindig használj zárójelet.

```taphome
VAR status := MODBUSR(H, 5, Uint16);
IF((status & 0x04) > 0, "Door open", "Door closed");
```

Nézd meg a bitműveletek példáját a [Google Táblázatokban](https://docs.google.com/spreadsheets/d/1hF5FMpGMJbgYh-YLwWrq2n186_ATyGyLUb689__IhLY/edit?usp=sharing), vagy próbáld ki az interaktív eszközt: [bitwisecmd.com](http://bitwisecmd.com/).