---
title: "Operații pe biți"
description: "Operații pe biți în scripturile TapHome: GETBIT, GETBITS, GETBYTE, SETBYTE, SETBIT, SETBITS, conversie BCD, lățime de 8/16/32/64 de biți, deplasarea biților, AND și OR pe biți cu echivalentele din Excel."
url: "https://taphome.com/ro/docs/script/bit-operations/"
language: ro
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["bit-operations","byte-manipulation","bitwise-operators","scripting-language"]
  questions: ["Cum se citește un singur bit dintr-un număr în TapHome?","Cum se extrage un octet dintr-un număr cu GETBYTE?","Cum se setează un anumit bit sau octet într-un script TapHome?","Cum se face o deplasare a biților la stânga sau la dreapta în TapHome?","Cum funcționează AND și OR pe biți în scripturile TapHome?","Care sunt echivalentele din Excel ale operatorilor pe biți din TapHome?","Câți biți folosesc funcțiile pe biți pentru o valoare pe 16 sau pe 64 de biți?","Cum se convertește un număr în sau din BCD?"]
---

# Operații pe biți

Manipularea biților și octeților în scripturile TapHome — GETBIT, GETBITS, SETBIT, SETBITS, GETBYTE, SETBYTE, TOBCD, FROMBCD, lățimea în biți după tip și operatorii pe biți cu echivalentele din Excel.

Ultima actualizare: 2026-11-06

Aceste funcții citesc și modifică biți individuali, câmpuri de biți și octeți ai unui număr întreg — de regulă cuvinte de stare și registre de alarmă citite cu `MODBUSR`. Bitul 0 este bitul cel mai puțin semnificativ (cel din dreapta), iar octetul 0 este octetul cel mai puțin semnificativ.

## Lățimea în biți după tip

Câți biți are un număr pentru funcțiile pe biți depinde de tipul lui:

| Tipul lui `number` | Biți | `bit` / `startBit` | `index` octet | Rezultatul lui `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` |
| toate celelalte (`double`, `float`, `int`, `uint`, …) | 32 | 0 – 31 | 0 – 3 | `uint` |

- `MODBUSR`, literalii zecimali, `PARSEJSON` și valorile dispozitivelor sunt de tip `double`, deci contează ca 32 de biți. Doar variabilele cu tip, elementele colecțiilor și tipurile de date Modbus pe 64 de biți au o altă lățime.
- Un bit sau un octet în afara tipului este o eroare, de exemplu `GETBIT(x, 16)` pentru o variabilă `uint16`: *GETBIT - bit must be between 0 and 15*. Un câmp de biți care **începe** în interiorul tipului, dar depășește limita lui superioară este permis — `GETBITS` returnează biții care există, iar `SETBITS` îi ignoră pe ceilalți.
- Un `double` sau `float` se rotunjește la un număr întreg și trebuie să fie între −2 147 483 648 și 4 294 967 295; orice altă valoare, inclusiv `NaN`, este o eroare (*value X is out of the 32-bit range*). Valorile negative folosesc complementul față de doi, deci `GETBITS(-1, 0, 16)` este `65535`.

**Disponibilitate** — lățimea după tip necesită TapHome Next 2026.1.40665+. Build-urile mai vechi tratează fiecare valoare ca 32 de biți: o valoare pe 64 de biți își pierde jumătatea superioară, iar un bit peste un tip pe 8 sau 16 biți returnează `0`.

## GETBIT

`GETBIT` returnează valoarea unui singur bit al unui număr, `0` sau `1`.

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

**Exemplu**

```taphome
# citește un singur bit dintr-un număr
GETBIT(2, 0);
# Result: 0
GETBIT(4, 2);
# Result: 1
# generează eroarea 3 dacă bitul 3 al registrului este setat
IF(GETBIT(MODBUSR(H, 600, Uint16), 3) = 1, ADDERROR(3, "Overheating"));
```

## GETBITS

`GETBITS` returnează un câmp de biți — `numberOfBits` biți începând de la `startBit` — ca număr întreg fără semn.

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

**Parametri** — `numberOfBits` este 1 – 32 sau 1 – 64 pentru un `number` pe 64 de biți.

**Exemplu**

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

Data și ora împachetate câte doi octeți pe registru (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` returnează numărul cu un bit setat la 0 (când `value` este 0) sau la 1 (orice altă `value`).

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

**Exemplu**

```taphome
# setează bitul 1 al lui 1 la 1, apoi bitul 2 al lui 4 la 0
SETBIT(1, 1, 1);
# Result: 3
SETBIT(4, 2, 0);
# Result: 0
# setează bitul 40 al unei variabile pe 64 de biți și îl citește înapoi
uint64 alarms := 0;
alarms := SETBIT(alarms, 40, 1);
GETBIT(alarms, 40);
# Result: 1 (a 64-bit variable has bits 0 to 63)
```

## SETBITS

`SETBITS` returnează numărul în care câmpul de `numberOfBits` biți care începe de la `startBit` este înlocuit cu `value`.

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

**Exemplu**

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

**Erori** — *Given number of bits (2) is not enought for storing the value 4.* când `value` nu încape în câmp (mesajul este scris chiar așa).

## GETBYTE

`GETBYTE` returnează un octet al unui număr (0 – 255) ca `uint`.

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

**Exemplu**

```taphome
# indexul 0 este octetul cel mai puțin semnificativ, indexul 1 următorul
GETBYTE(256, 0);
# Result: 0
GETBYTE(256, 1);
# Result: 1
# 259 este 0x0103, deci octetul 0 are valoarea 3
GETBYTE(259, 0);
# Result: 3
```

## SETBYTE

`SETBYTE` returnează numărul în care octetul de la `index` este înlocuit cu `value` (0 – 255).

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

**Exemplu**

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

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

## TOBCD

`TOBCD` convertește un număr întreg în BCD împachetat — fiecare cifră zecimală în propriii 4 biți — și îl returnează ca `uint`; se păstrează cel mult 8 cifre.

```text
TOBCD(number)
```

**Exemplu**

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

## FROMBCD

`FROMBCD` convertește o valoare BCD împachetată înapoi într-un număr obișnuit.

```text
FROMBCD(number)
```

**Exemplu**

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

**Erori** — *FROMBCD - number 26 is not in BCD format* și poziția cifrei, când un grup de 4 biți este mai mare decât 9 (aici `0x1A`).

## Operatori pe biți și echivalentele din Excel

Operatorii lucrează cu numere întregi; un operand `double` se convertește mai întâi în `int64`, iar un operand `Null` dă `Null`. Lista completă și prioritățile se găsesc pe pagina [Operatori](https://taphome.com/ro/docs/script/operators/).

| Operator | Exemplu | Rezultat | Excel |
|---|---|---|---|
| `<<` deplasare de biți la stânga | `8 << 2` | `32` | `BITLSHIFT(number, shift_amount)` |
| `>>` deplasare de biți la dreapta | `32 >> 2` | `8` | `BITRSHIFT(number, shift_amount)` |
| `&` AND pe biți | `3 & 1` | `1` | `BITAND(number1, number2)` |
| `\|` OR pe biți | `2 \| 1` | `3` | `BITOR(number1, number2)` |
| `^` XOR pe biți | `5 ^ 1` | `4` | `BITXOR(number1, number2)` |

> [!WARNING]
> Operatorii pe biți leagă mai slab decât comparațiile: `a & 1 > 0` înseamnă `a & (1 > 0)`. Se folosesc întotdeauna paranteze.

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

Consultați exemplul operațiilor pe biți în [Google Sheets](https://docs.google.com/spreadsheets/d/1hF5FMpGMJbgYh-YLwWrq2n186_ATyGyLUb689__IhLY/edit?usp=sharing) sau încercați instrumentul interactiv [bitwisecmd.com](http://bitwisecmd.com/).
