---
title: "Bitoperationen"
description: "Bitoperationen in TapHome-Skripten: GETBIT, GETBITS, GETBYTE, SETBYTE, SETBIT, SETBITS, BCD-Umwandlung, Breite 8/16/32/64 Bit, Bitverschiebung, bitweises AND und OR mit Entsprechungen in Excel."
url: "https://taphome.com/de/docs/script/bit-operations/"
language: de
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["bit-operations","byte-manipulation","bitwise-operators","scripting-language"]
  questions: ["Wie lese ich in TapHome ein einzelnes Bit aus einer Zahl?","Wie hole ich mit GETBYTE ein Byte aus einer Zahl?","Wie setze ich in einem TapHome-Skript ein bestimmtes Bit oder Byte?","Wie führe ich in TapHome eine Bitverschiebung nach links oder rechts aus?","Wie funktionieren bitweises AND und OR in TapHome-Skripten?","Was sind die Excel-Entsprechungen der Bitoperatoren von TapHome?","Wie viele Bits verwenden die Bitfunktionen bei einem 16-Bit- oder 64-Bit-Wert?","Wie wandle ich eine Zahl in BCD um oder aus BCD zurück?"]
---

# Bitoperationen

Bit- und Bytemanipulation in TapHome-Skripten — GETBIT, GETBITS, SETBIT, SETBITS, GETBYTE, SETBYTE, TOBCD, FROMBCD, Bitbreite nach Typ und bitweise Operatoren mit Entsprechungen in Excel.

Zuletzt aktualisiert: 2026-11-06

Diese Funktionen lesen und ändern einzelne Bits, Bitfelder und Bytes einer ganzen Zahl — typischerweise Statuswörter und Alarmregister, die mit `MODBUSR` gelesen werden. Bit 0 ist das niederwertigste (ganz rechte) Bit und Byte 0 das niederwertigste Byte.

## Bitbreite nach Typ

Wie viele Bits eine Zahl für die Bitfunktionen hat, hängt von ihrem Typ ab:

| Typ von `number` | Bits | `bit` / `startBit` | Byte `index` | Ergebnis von `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` |
| alles andere (`double`, `float`, `int`, `uint`, …) | 32 | 0 – 31 | 0 – 3 | `uint` |

- `MODBUSR`, Dezimalliterale, `PARSEJSON` und Gerätewerte sind `double` und zählen daher als 32 Bit. Nur typisierte Variablen, Elemente von Sammlungen und die 64-Bit-Datentypen von Modbus haben eine andere Breite.
- Ein Bit oder Byte außerhalb des Typs ist ein Fehler, zum Beispiel `GETBIT(x, 16)` für eine Variable vom Typ `uint16`: *GETBIT - bit must be between 0 and 15*. Ein Bitfeld, das innerhalb des Typs **beginnt**, aber über seine Obergrenze hinausreicht, ist erlaubt — `GETBITS` gibt die vorhandenen Bits zurück und `SETBITS` verwirft den Rest.
- Ein `double` oder `float` wird auf eine ganze Zahl gerundet und muss zwischen −2 147 483 648 und 4 294 967 295 liegen; alles andere, einschließlich `NaN`, ist ein Fehler (*value X is out of the 32-bit range*). Negative Werte verwenden das Zweierkomplement, daher ergibt `GETBITS(-1, 0, 16)` den Wert `65535`.

**Verfügbar** — die Breite nach Typ erfordert TapHome Next 2026.1.40665+. Ältere Builds behandeln jeden Wert als 32 Bit: Ein 64-Bit-Wert verliert seine obere Hälfte, und ein Bit oberhalb eines 8-Bit- oder 16-Bit-Typs gibt `0` zurück.

## GETBIT

`GETBIT` gibt den Wert eines Bits einer Zahl zurück, `0` oder `1`.

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

**Beispiel**

```taphome
# liest ein einzelnes Bit einer Zahl
GETBIT(2, 0);
# Result: 0
GETBIT(4, 2);
# Result: 1
# löst Fehler 3 aus, wenn Bit 3 des Registers gesetzt ist
IF(GETBIT(MODBUSR(H, 600, Uint16), 3) = 1, ADDERROR(3, "Overheating"));
```

## GETBITS

`GETBITS` gibt ein Bitfeld — `numberOfBits` Bits ab `startBit` — als vorzeichenlose ganze Zahl zurück.

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

**Parameter** — `numberOfBits` ist 1 – 32, oder 1 – 64 bei einer 64-Bit-Zahl `number`.

**Beispiel**

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

Datum und Uhrzeit, gepackt als zwei Bytes pro Register (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` gibt die Zahl zurück, in der ein Bit auf 0 (wenn `value` 0 ist) oder auf 1 (bei jedem anderen `value`) gesetzt ist.

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

**Beispiel**

```taphome
# setzt Bit 1 von 1 auf 1, dann Bit 2 von 4 auf 0
SETBIT(1, 1, 1);
# Result: 3
SETBIT(4, 2, 0);
# Result: 0
# setzt Bit 40 einer 64-Bit-Variable und liest es zurück
uint64 alarms := 0;
alarms := SETBIT(alarms, 40, 1);
GETBIT(alarms, 40);
# Result: 1 (a 64-bit variable has bits 0 to 63)
```

## SETBITS

`SETBITS` gibt die Zahl zurück, in der das Bitfeld aus `numberOfBits` Bits ab `startBit` durch `value` ersetzt ist.

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

**Beispiel**

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

**Fehler** — *Given number of bits (2) is not enought for storing the value 4.*, wenn `value` nicht in das Feld passt (die Meldung ist im Original so geschrieben).

## GETBYTE

`GETBYTE` gibt ein Byte einer Zahl (0 – 255) als `uint` zurück.

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

**Beispiel**

```taphome
# Index 0 ist das niedrigste Byte, Index 1 das nächste
GETBYTE(256, 0);
# Result: 0
GETBYTE(256, 1);
# Result: 1
# 259 ist 0x0103, also ist Byte 0 gleich 3
GETBYTE(259, 0);
# Result: 3
```

## SETBYTE

`SETBYTE` gibt die Zahl zurück, in der das Byte an `index` durch `value` (0 – 255) ersetzt ist.

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

**Beispiel**

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

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

## TOBCD

`TOBCD` wandelt eine ganze Zahl in gepacktes BCD um — jede Dezimalziffer in eigenen 4 Bits — und gibt sie als `uint` zurück; bis zu 8 Ziffern bleiben erhalten.

```text
TOBCD(number)
```

**Beispiel**

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

## FROMBCD

`FROMBCD` wandelt einen gepackten BCD-Wert zurück in eine gewöhnliche Zahl um.

```text
FROMBCD(number)
```

**Beispiel**

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

**Fehler** — *FROMBCD - number 26 is not in BCD format* und die Position der Ziffer, wenn eine Gruppe von 4 Bits größer als 9 ist (hier `0x1A`).

## Bitweise Operatoren und Entsprechungen in Excel

Die Operatoren arbeiten mit ganzen Zahlen; ein Operand vom Typ `double` wird zuerst in `int64` umgewandelt, und ein Operand `Null` ergibt `Null`. Die vollständige Liste und die Rangfolge stehen auf [Operatoren](https://taphome.com/de/docs/script/operators/).

| Operator | Beispiel | Ergebnis | Excel |
|---|---|---|---|
| `<<` Bitverschiebung nach links | `8 << 2` | `32` | `BITLSHIFT(number, shift_amount)` |
| `>>` Bitverschiebung nach rechts | `32 >> 2` | `8` | `BITRSHIFT(number, shift_amount)` |
| `&` bitweises AND | `3 & 1` | `1` | `BITAND(number1, number2)` |
| `\|` bitweises OR | `2 \| 1` | `3` | `BITOR(number1, number2)` |
| `^` bitweises XOR | `5 ^ 1` | `4` | `BITXOR(number1, number2)` |

> [!WARNING]
> Die bitweisen Operatoren binden schwächer als Vergleiche: `a & 1 > 0` bedeutet `a & (1 > 0)`. Verwenden Sie immer Klammern.

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

Sehen Sie sich das Beispiel für Bitoperationen in [Google Sheets](https://docs.google.com/spreadsheets/d/1hF5FMpGMJbgYh-YLwWrq2n186_ATyGyLUb689__IhLY/edit?usp=sharing) an, oder probieren Sie das interaktive Werkzeug unter [bitwisecmd.com](http://bitwisecmd.com/) aus.