---
title: "Tipi di dati Modbus"
description: "Tipi di dati Modbus TapHome: registri e intervallo di Int16, Uint32, Float e dei tipi a 64 bit, varianti BigEndian, LittleEndian e ByteSwap, arrotondamento in scrittura."
url: "https://taphome.com/it/docs/script/modbus-data-types/"
language: it
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["modbus","modbus-data-types","byte-order","scripting-language"]
  questions: ["Quali tipi di dati Modbus posso usare negli script TapHome?","Quanti registri occupa un Float o un valore a 64 bit?","Che cosa significano BigEndian, LittleEndian e ByteSwap per i registri Modbus?","Quale tipo di dati corrisponde all'ordine dei byte ABCD, CDAB, BADC o DCBA indicato nel manuale di un dispositivo?","Come leggo un registro Modbus a 64 bit?","Come leggo una stringa di testo dai registri Modbus?","Come viene arrotondato un valore decimale scritto in un registro intero?"]
---

# Tipi di dati Modbus

Tipi di dati Modbus negli script TapHome — Int16, Uint16, Int32, UInt32, Float, Bool, String e i tipi a 64 bit Int64, UInt64 e Double — con varianti big-endian, little-endian e byte swap.

Ultimo aggiornamento: 2026-11-06

Il tipo di dati è il terzo argomento di [MODBUSR](https://taphome.com/it/docs/script/modbus/#modbusr), [MODBUSW](https://taphome.com/it/docs/script/modbus/#modbusw) e [MODBUSWNE](https://taphome.com/it/docs/script/modbus/#modbuswne) e di [UNPACKVALUE e PACKVALUE](https://taphome.com/it/docs/script/binary-data/). Decide quanti registri a 16 bit occupa un valore e in quale ordine sono memorizzati i suoi byte. I nomi dei tipi di dati non distinguono tra maiuscole e minuscole.

## Tipi di dati di base

Ogni tipo di dati di base occupa un numero fisso di registri a 16 bit e fornisce allo script un valore di un tipo fisso.

| Tipo | Registri | Intervallo | Valore nello script |
|---|---|---|---|
| `Bool` | 1 | 0 = `FALSE`, qualsiasi altro valore `TRUE` | `bool` |
| `Int16` | 1 | −32 768 … 32 767 | numero |
| `Uint16` | 1 | 0 … 65 535 | numero |
| `Int32` | 2 | −2 147 483 648 … 2 147 483 647 | numero |
| `UInt32` | 2 | 0 … 4 294 967 295 | numero |
| `Float` | 2 | IEEE 754 a precisione singola | numero |
| `Int64`, `UInt64` | 4 | numeri interi a 64 bit | `int64`, `uint64` |
| `Double` | 4 | IEEE 754 a precisione doppia | numero |
| `String` | 1 – 123 | 2 caratteri per registro | string |

Molti dispositivi memorizzano un valore decimale come numero intero con una scala fissa — dividilo dopo la lettura, ad esempio `MODBUSR(H, 20, Int16) / 10`. I valori codificati in BCD si convertono con [FROMBCD](https://taphome.com/it/docs/script/bit-operations/#frombcd).

## Varianti dell'ordine dei byte

Ogni tipo esiste in una variante big-endian e in una little-endian; i tipi a 32 e 64 bit anche in varianti byte swap.

```text
BigEndianInt16      LittleEndianInt16
BigEndianUint16     LittleEndianUint16
BigEndianInt32      LittleEndianInt32       BigEndianInt32ByteSwap      LittleEndianInt32ByteSwap
BigEndianUint32     LittleEndianUint32      BigEndianUint32ByteSwap     LittleEndianUint32ByteSwap
BigEndianFloat      LittleEndianFloat       BigEndianFloatByteSwap      LittleEndianFloatByteSwap
BigEndianInt64      LittleEndianInt64       BigEndianInt64ByteSwap      LittleEndianInt64ByteSwap
BigEndianUint64     LittleEndianUint64      BigEndianUint64ByteSwap     LittleEndianUint64ByteSwap
BigEndianDouble     LittleEndianDouble      BigEndianDoubleByteSwap     LittleEndianDoubleByteSwap
```

| Flag | Significato per i registri |
|---|---|
| `BigEndian` | Il registro più significativo viene per primo. È il valore predefinito: `Int32` è `BigEndianInt32`. |
| `LittleEndian` | L'ordine dei registri è invertito (word swap). Per un tipo a 16 bit, che ha un solo registro, vengono scambiati i due byte al suo interno. |
| `ByteSwap` | I due byte all'interno di ogni registro vengono scambiati. |

I manuali dei dispositivi indicano spesso l'ordine dei byte con delle lettere: A è il byte più significativo del valore e le lettere seguono l'ordine in cui il dispositivo invia i byte. Ogni ordine corrisponde a un tipo di dati:

| Nel manuale | Tipo a 32 bit | Tipo a 64 bit |
|---|---|---|
| ABCD (big-endian) | `BigEndianFloat` (equivale a `Float`) | `BigEndianDouble` (equivale a `Double`), ABCDEFGH |
| CDAB (word swap) | `LittleEndianFloat` | `LittleEndianDouble`, GHEFCDAB |
| BADC (byte swap) | `BigEndianFloatByteSwap` | `BigEndianDoubleByteSwap`, BADCFEHG |
| DCBA (little-endian) | `LittleEndianFloatByteSwap` | `LittleEndianDoubleByteSwap`, HGFEDCBA |

Lo stesso vale per i tipi interi, ad esempio CDAB è `LittleEndianInt32` e DCBA è `LittleEndianUint32ByteSwap`.

**Note**

- Lettura e scrittura applicano tutti i flag allo stesso modo, quindi scrivere un valore e rileggerlo con lo stesso tipo dà lo stesso valore. Sui Core precedenti alla 2026.1, `MODBUSW` e `MODBUSWNE` ignoravano `ByteSwap` per `Int32` e `UInt32`.
- Quando un valore viene letto senza senso, prova le varianti nelle operazioni Modbus manuali dell'app, che cambiano il tipo di dati sugli stessi registri.
- In una collezione di byte i flag indicano invece l'ordine dei byte — vedi [Ordine dei byte nelle collezioni](https://taphome.com/it/docs/script/binary-data/#byte-order).

**Esempio**

```taphome
MODBUSR(H, 0x0100, LittleEndianFloat);
MODBUSR(A, 30, BigEndianUint32ByteSwap);
```

## Tipi di dati a 64 bit

`Int64`, `UInt64` e `Double` occupano quattro registri; `Int64` e `UInt64` vengono letti come numeri interi a 64 bit, esatti su tutto l'intervallo, perché un `double` rappresenta esattamente i numeri interi solo fino a 2^53.

**Note** — Un valore a 64 bit mantiene tutti i 64 bit nelle [funzioni sui bit](https://taphome.com/it/docs/script/bit-operations/), quindi i bit da 32 a 63 di una parola di allarme sono raggiungibili.

**Esempio — contatore di energia in Wh, mostrato in kWh**

```taphome
VAR energy := MODBUSR(H, 100, UInt64);
energy / 1000;
```

**Errori** — *Modbus data type 'X' not supported. Please update your core unit to be able to use this feature.* — quando lo script viene salvato per un Core più vecchio.

**Disponibile** — TapHome Next 2026.1.40665+.

## String

`String` legge un testo memorizzato con due caratteri per registro, prima il byte alto; il numero di registri è il quarto argomento.

**Note**

- `MODBUSR` legge da 0 a 123 registri; il testo termina al primo byte zero. Ogni byte è un carattere.
- `String` si può solo leggere. `MODBUSW` e `PACKVALUE` non lo scrivono.

**Esempio**

```taphome
MODBUSR(H, 14, String, 4);
# Result: text of up to 8 characters, for example a serial number
```

## Scrittura dei valori

`MODBUSW`, `MODBUSWNE` e `PACKVALUE` convertono il valore nel tipo di dati prima della scrittura.

- I tipi interi arrotondano al numero intero più vicino; un valore esattamente a metà va al numero pari, quindi `2.5` viene scritto come `2` e `3.5` come `4`.
- Un valore fuori dall'intervallo di `Int16`, `Uint16` o `Float` interrompe lo script: *Overflow when writing X as UInt16.*
- `NaN` si può scrivere solo in `Float` e `Double`. In un tipo intero interrompe lo script: *RegisterValueToWrites: Can't write double.NaN to modbus register* (`MODBUSW`, `MODBUSWNE`) o *PACKVALUE: Can't write double.NaN to modbus register*.
- `Bool` scrive 1 per qualsiasi valore diverso da 0. `TRUE` e `FALSE` si possono scrivere anche nei tipi numerici come 1 e 0.

**Esempio — setpoint con un decimale**

```taphome
MODBUSW(H, 20, Int16, ROUND(Te * 10));
```

**Vedi anche** — [Funzioni Modbus](https://taphome.com/it/docs/script/modbus/), [Script Modbus e prefetch](https://taphome.com/it/docs/script/modbus-scripts/), [Dati binari](https://taphome.com/it/docs/script/binary-data/).
