---
title: "Bitové operácie"
description: "Bitové operácie skriptovacieho jazyka TapHome: GETBIT, GETBITS, GETBYTE, SETBYTE, SETBIT, SETBITS, prevod BCD, šírka 8/16/32/64 bitov, posun bitov, bitové AND a OR s ekvivalentmi v Exceli."
url: "https://taphome.com/sk/docs/script/bit-operations/"
language: sk
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["bit-operations","byte-manipulation","bitwise-operators","scripting-language"]
  questions: ["Ako prečítam jeden bit z čísla v TapHome?","Ako získam bajt z čísla pomocou GETBYTE?","Ako nastavím konkrétny bit alebo bajt v TapHome skripte?","Ako vykonám posun bitov doľava alebo doprava v TapHome?","Ako fungujú bitové AND a OR v TapHome skriptoch?","Aké sú ekvivalenty bitových operátorov TapHome v Exceli?","Koľko bitov používajú bitové funkcie pre 16-bitovú alebo 64-bitovú hodnotu?","Ako prevediem číslo do BCD alebo z BCD?"]
---

# Bitové operácie

Práca s bitmi a bajtmi v skripte TapHome — GETBIT, GETBITS, SETBIT, SETBITS, GETBYTE, SETBYTE, TOBCD, FROMBCD, šírka v bitoch podľa typu a bitové operátory s ekvivalentmi v Exceli.

Posledná aktualizácia: 2026-11-06

Tieto funkcie čítajú a menia jednotlivé bity, bitové polia a bajty celého čísla — typicky stavových slov a alarmových registrov prečítaných pomocou `MODBUSR`. Bit 0 je najmenej významný (najpravejší) bit a bajt 0 je najmenej významný bajt.

## Šírka v bitoch podľa typu

Koľko bitov má číslo pre bitové funkcie, závisí od jeho typu:

| Typ `number` | Bity | `bit` / `startBit` | `index` bajtu | Výsledok `GETBITS`, `SETBIT`, `SETBITS`, `SETBYTE` |
|---|---|---|---|---|
| `int8`, `uint8` | 8 | 0 – 7 | 0 | `uint` |
| `int16`, `uint16` | 16 | 0 – 15 | 0 – 1 | `uint` |
| `int64`, `uint64` | 64 | 0 – 63 | 0 – 7 | `uint64` |
| všetko ostatné (`double`, `float`, `int`, `uint`, …) | 32 | 0 – 31 | 0 – 3 | `uint` |

- `MODBUSR`, desatinné literály, `PARSEJSON` a hodnoty zariadení sú `double`, preto sa rátajú ako 32 bitov. Inú šírku majú iba typované premenné, prvky kolekcií a 64-bitové dátové typy Modbus.
- Bit alebo bajt mimo typu je chyba, napríklad `GETBIT(x, 16)` pre premennú typu `uint16`: *GETBIT - bit must be between 0 and 15*. Bitové pole, ktoré **začína** vo vnútri typu, ale presahuje jeho horný okraj, je povolené — `GETBITS` vráti bity, ktoré existujú, a `SETBITS` ostatné zahodí.
- `double` alebo `float` sa zaokrúhli na celé číslo a musí byť v rozsahu −2 147 483 648 až 4 294 967 295; čokoľvek iné, vrátane `NaN`, je chyba (*value X is out of the 32-bit range*). Záporné hodnoty sa berú v dvojkovom doplnku, preto `GETBITS(-1, 0, 16)` je `65535`.

**Dostupnosť** — šírka podľa typu potrebuje TapHome Next 2026.1.40665+. Staršie buildy berú každú hodnotu ako 32-bitovú: 64-bitová hodnota stratí hornú polovicu a bit nad 8-bitovým alebo 16-bitovým typom vráti `0`.

## GETBIT

`GETBIT` vráti hodnotu jedného bitu čísla, `0` alebo `1`.

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

**Príklad**

```taphome
# načíta jeden bit zo zadaného čísla
GETBIT(2, 0);
# Result: 0
GETBIT(4, 2);
# Result: 1
# vyvolá chybu 3, ak je bit 3 registra nastavený
IF(GETBIT(MODBUSR(H, 600, Uint16), 3) = 1, ADDERROR(3, "Overheating"));
```

## GETBITS

`GETBITS` vráti bitové pole — `numberOfBits` bitov od `startBit` — ako celé číslo bez znamienka.

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

**Parametre** — `numberOfBits` je 1 – 32, alebo 1 – 64 pre 64-bitové `number`.

**Príklad**

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

Dátum a čas zabalené po dvoch bajtoch v registri (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

`SETBIT` vráti číslo s jedným bitom nastaveným na 0 (keď je `value` 0) alebo na 1 (pri akejkoľvek inej hodnote `value`).

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

**Príklad**

```taphome
# nastaví bit 1 čísla 1 na 1, potom bit 2 čísla 4 na 0
SETBIT(1, 1, 1);
# Result: 3
SETBIT(4, 2, 0);
# Result: 0
# nastaví bit 40 64-bitovej premennej a prečíta ho späť
uint64 alarms := 0;
alarms := SETBIT(alarms, 40, 1);
GETBIT(alarms, 40);
# Result: 1 (a 64-bit variable has bits 0 to 63)
```

## SETBITS

`SETBITS` vráti číslo, v ktorom je bitové pole s `numberOfBits` bitmi od `startBit` nahradené hodnotou `value`.

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

**Príklad**

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

**Chyby** — *Given number of bits (2) is not enought for storing the value 4.*, keď sa `value` do poľa nevojde (preklep „enought“ je priamo v hláške).

## GETBYTE

`GETBYTE` vráti jeden bajt čísla (0 – 255) ako `uint`.

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

**Príklad**

```taphome
# index 0 je najnižší bajt, index 1 nasledujúci
GETBYTE(256, 0);
# Result: 0
GETBYTE(256, 1);
# Result: 1
# 259 je 0x0103, takže bajt 0 je 3
GETBYTE(259, 0);
# Result: 3
```

## SETBYTE

`SETBYTE` vráti číslo, v ktorom je bajt na pozícii `index` nahradený hodnotou `value` (0 – 255).

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

**Príklad**

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

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

## TOBCD

`TOBCD` prevedie celé číslo do zabaleného BCD — každá desiatková číslica vo vlastných 4 bitoch — a vráti ho ako `uint`; zachová sa najviac 8 číslic.

```text
TOBCD(number)
```

**Príklad**

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

## FROMBCD

`FROMBCD` prevedie zabalenú hodnotu BCD späť na bežné číslo.

```text
FROMBCD(number)
```

**Príklad**

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

**Chyby** — *FROMBCD - number 26 is not in BCD format* spolu s pozíciou číslice, keď je niektorá skupina 4 bitov väčšia ako 9 (tu `0x1A`).

## Bitové operátory a ekvivalenty v Exceli

Operátory pracujú s celými číslami; operand typu `double` sa najprv prevedie na `int64` a operand `Null` dá `Null`. Úplný zoznam a priority sú na stránke [Operátory](https://taphome.com/sk/docs/script/operators/).

| Operátor | Príklad | Výsledok | Excel |
|---|---|---|---|
| `<<` posun bitov doľava | `8 << 2` | `32` | `BITLSHIFT(number, shift_amount)` |
| `>>` posun bitov doprava | `32 >> 2` | `8` | `BITRSHIFT(number, shift_amount)` |
| `&` bitové AND | `3 & 1` | `1` | `BITAND(number1, number2)` |
| `\|` bitové OR | `2 \| 1` | `3` | `BITOR(number1, number2)` |
| `^` bitové XOR | `5 ^ 1` | `4` | `BITXOR(number1, number2)` |

> [!WARNING]
> Bitové operátory viažu slabšie ako porovnania: `a & 1 > 0` znamená `a & (1 > 0)`. Vždy používajte zátvorky.

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

Príklad bitových operácií nájdete v [Google Sheets](https://docs.google.com/spreadsheets/d/1hF5FMpGMJbgYh-YLwWrq2n186_ATyGyLUb689__IhLY/edit?usp=sharing), prípadne si ich vyskúšajte v interaktívnom nástroji [bitwisecmd.com](http://bitwisecmd.com/).