---
title: "TapHome către Modbus RTU / ASCII / TCP"
description: "Integrați TapHome într-un BMS sau SCADA prin Modbus: un exemplu complet cu harta registrelor pe partea TapHome, lista de puncte pentru master și un exemplu Python."
url: "https://taphome.com/ro/docs/expose-devices/modbus/"
language: ro
lastmod: 2026-11-09
generator: hugo
ai:
  topics: ["modbus-integration","expose-devices","bms-integration","modbus-tcp","rs485-communication","system-integration"]
  questions: ["Cum integrez TapHome într-un sistem BMS sau SCADA?","Cum expun dispozitivele TapHome prin Modbus?","Cum arată harta registrelor Modbus a TapHome?","Ce adresă de registru folosește BMS-ul pentru o valoare expusă?","Ce tipuri de registre și tipuri de date poate folosi o valoare expusă?","Ce returnează registrul de validitate?","Cum declanșează un master Modbus o acțiune a unui dispozitiv, de exemplu o comandă pentru jaluzele?","La ce Slave ID răspunde TapHome?","De ce primește masterul excepția Modbus 0x02 sau 0x0A?","Ce s-a schimbat la interfețele Modbus slave în TapHome 2026.1?"]
---

# TapHome către Modbus RTU / ASCII / TCP

TapHome ca Modbus slave pentru BMS, SCADA sau PLC prin Modbus TCP, RTU sau ASCII: alegeți valorile și acțiunile dispozitivelor și predați masterului harta registrelor.

Ultima actualizare: 2026-11-09

TapHome poate funcționa ca Modbus slave (server), astfel încât un sistem de management al clădirii (BMS), un SCADA sau un PLC citește și controlează dispozitivele TapHome prin Modbus TCP ori prin Modbus RTU sau ASCII pe RS485. În **Expuneți dispozitivele** alegeți valorile și acțiunile fiecărui dispozitiv, TapHome atribuie fiecăreia propriul registru, iar rezultatul este o hartă a registrelor pe care o predați celui care configurează masterul. Dispozitivele pot fi citite astfel și de un al doilea Core ([conectarea mai multor Core](https://taphome.com/ro/docs/configuration/multiple-cores/)).

## Cum funcționează

1. **Pe Core** adăugați o interfață Modbus și alegeți ce poate vedea și face masterul: valori (temperatură, nivelul de jaluzele, starea comutatorului …) și acțiuni (comenzi pentru jaluzele, comutare …).
2. **Harta registrelor** se construiește pe măsură ce alegeți: fiecare valoare primește un interval de registre la următoarea adresă liberă, urmat imediat de registrul ei de validitate.
3. **Pe master**, integratorul introduce aceleași registre ca puncte sau tag-uri. Citirea returnează valoarea curentă; scrierea modifică dispozitivul ca o intervenție manuală, la fel ca în aplicație.

Core continuă să-și controleze propriile module și să-și execute smart rules; Modbus partajează doar valorile și acțiunile pe care le-ați ales.

## Exemplu: jaluzele și termostat pentru un BMS

BMS-ul unei clădiri citește temperatura din cameră, setează temperatura dorită a termostatului și poate opri jaluzelele. Pe Core, în **Expuneți dispozitivele**, selectați **Adăugați o nouă interfață** → **Modbus TCP**, apoi adăugați jaluzelele și termostatul. Aceasta este întreaga configurație pe partea TapHome — faceți clic pe un registru sau pe **Adăugați dispozitiv** pentru a vedea pasul următor:



1. **Adresa IP a unității Core** — BMS-ul se conectează la ea. Atribuiți unității Core o adresă fixă, de exemplu printr-o rezervare DHCP în router.
2. **Slave ID** — BMS-ul trebuie să trimită același Unit ID; o cerere cu alt Unit ID primește excepția 0x0A.
3. **O valoare** ocupă două registre: valoarea propriu-zisă și, imediat după ea, registrul de validitate. *×100* este multiplicatorul: nivelul de jaluzele 0,55 se citește ca 55.
4. **O acțiune** are un singur registru, în care scrie BMS-ul. Stop este un coil: scrierea valorii ON oprește jaluzelele.
5. **Setările registrului** — tipul registrului, indexul, tipul de date, multiplicatorul, ordinea octeților și registrul de validitate. De regulă, valorile implicite sunt potrivite; modificați indexul atunci când BMS-ul așteaptă o dispunere fixă.
6. **Adăugați dispozitiv** — bifați valorile și acțiunile dispozitivului; **OK** le adaugă la următoarele adrese libere. Valorile care pot fi scrise primesc un holding register (H) sau un coil (C), iar cele doar pentru citire un input register (A) sau un discrete input (D).

## Pe partea BMS sau SCADA

Masterul are nevoie de adresa IP și portul unității Core (sau de setările liniei RS485), de Slave ID și de lista de puncte. Pentru exemplul de mai sus:

**Lista de puncte**

| Punct                             | Registru TapHome | Notație de la 1 | Cod de funcție        | Valoare     |
|-----------------------------------|------------------|-----------------|-----------------------|-------------|
| Nivelul de jaluzele               | H 0              | 40001           | 03 citire, 06 scriere | 0–100       |
| Validitatea nivelului de jaluzele | H 1              | 40002           | 03                    | 0 = valid   |
| Unghiul șipcilor                  | H 2              | 40003           | 03 citire, 06 scriere | 0–100       |
| Validitatea unghiului șipcilor    | H 3              | 40004           | 03                    | 0 = valid   |
| Oprirea jaluzelelor               | C 4              | 00005           | 05 scriere            | ON = oprire |
| Temperatură                       | A 5              | 30006           | 04                    | ÷ 10 = °C   |
| Validitatea temperaturii          | A 6              | 30007           | 04                    | 0 = valid   |
| Temperatura dorită                | H 7              | 40008           | 03 citire, 06 scriere | ÷ 10 = °C   |
| Validitatea temperaturii dorite   | H 8              | 40009           | 03                    | 0 = valid   |

Toate registrele sunt Int16 (un coil este un bit). H = holding register, A = input register, C = coil.

> TapHome numerotează registrele de la 0, așa cum sunt trimise în cerere. Masterele care folosesc notația de la 1 (40001 pentru holding register 0) au numere mai mari cu unu — decalajul de unu este cea mai frecventă cauză a citirii unei valori greșite.



**Python (pymodbus)**

Citirea și scrierea exemplului cu [pymodbus](https://github.com/pymodbus-dev/pymodbus) 3.16:

\```python from pymodbus.client import ModbusTcpClient client = ModbusTcpClient(&#34;192.168.1.50&#34;, port=502) client.connect() # Temperatură: input register 5 (valoare × 10) și 6 (validitate, 0 = valid) rr = client.read\_input\_registers(5, count=2, device\_id=1) value, validity = client.convert\_from\_registers(rr.registers, client.DATATYPE.INT16) if validity == 0: print(f&#34;Temperature: {value / 10} °C&#34;) # Temperatura dorită 22,5 °C: holding register 7, scrisă × 10 client.write\_register(7, 225, device\_id=1) # Oprirea jaluzelelor: scrierea valorii ON în coil-ul 4 client.write\_coil(4, True, device\_id=1) client.close() \`\`\`

Biblioteci pentru alte limbaje: [NModbus4](https://github.com/NModbus4/NModbus4) (C#), [libmodbus](https://libmodbus.org) (C), [digitalpetri/modbus](https://github.com/digitalpetri/modbus) (Java), [goburrow/modbus](https://github.com/goburrow/modbus) (Go). [Simply Modbus](http://www.simplymodbus.ca/) explică protocolul.

Masterul ar trebui să citească registrul de validitate împreună cu valoarea (o singură cerere pentru ambele) și să trateze orice cod diferit de 0 ca defect — un dispozitiv pierdut apare astfel în BMS ca defect, nu ca valoare înghețată.

## Interfețe și proprietăți de comunicație

| Interfață | Proprietăți | Implicit |
|---|---|---|
| **Modbus TCP** | **TCP port**, **Slave ID** | portul 502, următorul Slave ID liber pe port |
| **Modbus RTU**, **Modbus ASCII** | borna BUS 1, BUS 2 sau BUS 3, viteza de transmisie, biți de date, paritate, biți de stop, **Slave ID** | fără bornă, 9600 baud, 8 biți de date (ASCII 7), paritate None, 1 bit de stop, Slave ID 1 |

- **Mai multe mastere prin TCP:** mai multe interfețe Modbus TCP pot partaja un port dacă au Slave ID diferite — de exemplu una pentru BMS și una pentru un al doilea Core, fiecare cu propriile registre. Până la 10 conexiuni simultan.
- **RS485:** o interfață RTU sau ASCII pornește doar după ce alegeți o bornă, iar o bornă deservește o singură interfață.
- **Slave ID** ia valori de la 1 la 247. Interfața răspunde doar la propriul ID: Modbus TCP returnează excepția 0x0A pentru alt Unit ID (inclusiv 0 sau 255), iar RTU și ASCII nu răspund la cadrele destinate altei adrese.

Lista interfețelor afișează conflictele, de exemplu același port și același Slave ID de două ori sau o interfață fără bornă.

## Setările registrului

| Setare | Valori |
|---|---|
| **Tip de registru** | **H** holding register, **A** input register, **C** coil, **D** discrete input. Masterul poate scrie doar H și C. |
| **Indexul registrului** | De la 0 la 65535, adresa din cererea Modbus. |
| **Tip de date** | Bool, Int16 și UInt16 ocupă un registru, Int32, UInt32 și Float două. C și D transportă doar Bool. |
| **Multiplier** | Citire: registru = valoare × multiplicator. Scriere: valoare = registru ÷ multiplicator. Temperaturile au implicit ×10, nivelurile și procentele ×100 (0,55 → 55). |
| **Threshold** | În locul multiplicatorului, pentru Bool pe o valoare numerică: true când valoarea este cel puțin egală cu pragul; scrierea true într-un coil setează valoarea la prag, iar false la 0. |
| **Endianness** | BigEndian sau LittleEndian; **Byte swap** inversează în plus octeții din fiecare registru al tipurilor Int32, UInt32 și Float. |

Detaliul interfeței marchează registrele ale căror intervale se suprapun. O valoare suprapusă nu este furnizată — dați fiecărei valori propriul interval, inclusiv registrul ei de validitate.

## Registrul de validitate și valoarea de rezervă

**Include validity register** (la C și D **Include validity bit**) este activat implicit. Registrul doar pentru citire aflat imediat după valoare îi spune masterului dacă valoarea este validă; când nu este, registrele valorii returnează în schimb **Fallback value** (la Float, NaN cu **Use NaN as fallback**).

| Cod | Semnificație |
|---|---|
| 0 | valid |
| 1 | valoarea nu se încadrează în tipul de date (de exemplu NaN într-un tip întreg) |
| 2 | dispozitivul nu este disponibil sau este în eroare |
| 3 | setările registrului nu sunt valide |
| 5 | încă nu există nicio valoare, de exemplu imediat după pornirea unității Core |

La C și D, bitul de validitate este 1 când valoarea nu este validă.

## Acțiuni

- **O acțiune fără parametri** (Stop, Toggle …) are un registru pe H sau C. Scrierea valorii 1 sau mai mari, ori coil ON, o declanșează; scrierea valorii 0 returnează excepția 0x03.
- **O acțiune cu parametri** (adăugarea la nivelul de jaluzele, setarea unui interval …) are câte un holding register pentru fiecare parametru, unul după altul. O singură scriere trebuie să le acopere pe toate; scrierea doar a unora returnează excepția 0x03.
- Registrele acțiunilor sunt doar pentru scriere — citirea lor returnează excepția 0x02.

## Ce primește masterul

TapHome acceptă codurile de funcție 01, 02, 03, 04, 05, 06, 15 și 16. O cerere poate citi mai multe valori consecutive; în caz contrar, masterul primește o excepție:

| Excepție | Când |
|---|---|
| 0x01 | un cod de funcție neacceptat |
| 0x02 | o adresă neatribuită niciunei valori, un interval cu un gol, o scriere pe A sau D, citirea unui registru de acțiune, o scriere într-un registru de validitate |
| 0x03 | o valoare pe care dispozitivul nu o poate accepta sau o scriere nevalidă a unei acțiuni; o scriere cu mai multe valori se aplică integral sau deloc |
| 0x04 | dispozitivul a refuzat scrierea |
| 0x0A | Modbus TCP: alt Slave ID (Unit ID) decât cel al interfeței |

Modbus TCP închide o conexiune inactivă timp de 15 minute.

## Actualizarea la 2026.1

> [!WARNING]
> La actualizarea unității de control la 2026.1, interfețele Modbus slave existente se convertesc automat, păstrând adresele registrelor și Slave ID-ul. Registrul Stop al unei jaluzele KNX, al unei jaluzele Packet parser, al unui dispozitiv **Marchiză** Packet parser și al unui dispozitiv **Marchiză** virtual nu se convertește; un master care îl folosea primește la adresa lui excepția 0x02 ([notele de versiune 2026.1](https://taphome.com/ro/docs/release-notes/2026-1/#expose-devices)).

Începând cu 2026.1, Modbus TCP răspunde doar la propriul Slave ID — dacă masterul dvs. trimite Unit ID 0 sau 255, setați-l la Slave ID-ul interfeței.

## Depanarea conexiunilor Modbus RTU

RS485 este o magistrală partajată, așa că un PC cu un convertor USB la RS485 (de exemplu [FTDI USB-RS485-WE-1800-BT](https://ftdichip.com/products/usb-rs485-we-1800-bt/)) și un software de terminal, precum [Terminal](http://www.der-hammer.info/terminal/) pentru Windows, poate asculta comunicația în timpul integrării.
