---
title: "Orno OR-WE-517"
description: "Contor electric trifazat multitarif Orno OR-WE-517 cu Modbus RTU (RS-485). Șablon TapHome: energie pe faze și totală, 4 tarife și contoare bidirecționale."
url: "https://taphome.com/ro/compatibility/orno-or-we-517/"
language: ro
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["modbus-rtu","electric-meter","rs485","3-phase","energy-metering","din-rail","multitariff"]
  questions: ["Cum integrez Orno OR-WE-517 cu TapHome?","Ce măsoară șablonul TapHome pentru Orno OR-WE-517?","Cum conectez Orno OR-WE-517 prin RS-485 la TapHome?","Cum configurez programul tarifelor pe OR-WE-517?","Care este diferența dintre OR-WE-516 și OR-WE-517?","Cum setez adresa slave Modbus pe OR-WE-517?"]
---

# Orno OR-WE-517

Comunicație: Modbus RTU

- [Site-ul oficial Orno](https://www.orno.pl)

## Ghid de integrare

Orno OR-WE-517 este un contor electric trifazat multitarif pentru montaj pe șină DIN, care comunică prin Modbus RTU pe RS-485. Este un contor cu conectare directă, pentru maximum 80 A pe fază, cu certificare MID (Directiva 2014/32/UE), și ocupă 4,3 module pe o șină TH-35. Șablonul TapHome oferă 11 dispozitive de tip contor electric, care acoperă curentul pe faze, energia pe faze, energia trifazată totală și contoarele de energie pentru 4 tarife, împreună cu atribute de service pentru tensiune, putere reactivă/aparentă, factor de putere și defalcarea bidirecțională a energiei (directă/inversă).

Toate registrele de măsurare folosesc codificarea IEEE 754 Float32 (2 cuvinte Modbus pe valoare) și se citesc cu codul de funcție 03 (registre holding). Șablonul oferă și acțiuni de service pentru setarea ceasului de timp real al contorului, configurarea programului tarifelor și ajustarea Slave ID-ului Modbus.

## Conectarea hardware

### Cablarea RS-485

OR-WE-517 are o interfață RS-485 încorporată pentru comunicația Modbus RTU. Conectați contorul la magistrala RS-485 a TapHome Core cu un cablu de comunicație ecranat cu două fire:

- Borna **A** a contorului la **A+/D+** pe RS-485 TapHome
- Borna **B** a contorului la **B-/D-** pe RS-485 TapHome

> [!WARNING]
> Folosiți topologia liniară (**daisy-chain**). Topologiile în stea și cu derivații provoacă reflexii ale semnalului și erori de comunicare. Legătura dintre convertor și contor trebuie realizată cu un cablu de comunicație cu două fire, adaptat standardului RS-485.

> [!TIP]
> Pentru configurarea inițială și testare se poate folosi și un convertor USB-RS485 obișnuit. Convertorul nu este inclus cu contorul.

## Configurare

### Parametri de comunicație

Setările Modbus implicite corespund direct șablonului TapHome:

| Parametru | Implicit | Interval |
|-----------|---------|-------|
| Baud rate | 9600 bps | 1200, 2400, 4800, 9600 |
| Biți de date | 8 | Fix |
| Paritate | Pară (Even) | Fix |
| Biți de stop | 1 | Fix |
| Slave ID | 1 | 1–255 |

Cadrul de comunicație are format de 11 biți: 1 bit de start, 8 biți de date, 1 bit de paritate pară și 1 bit de stop, cu verificare CRC.

### Slave ID

Când conectați mai multe contoare pe aceeași magistrală RS-485, fiecare contor trebuie să aibă un Slave ID unic. Slave ID-ul implicit este 1 (configurabil de la 1 la 255 prin registrul holding H:2). După importul șablonului TapHome, ajustați Slave ID-ul în setările de conexiune ale modulului, astfel încât să corespundă contorului fizic. Șablonul oferă și acțiunea de service **Slave ID** pentru schimbarea adresei de la distanță, prin Modbus.

Slave ID-ul curent și baud rate-ul se văd pe afișajul LCD al contorului (paginile 42, respectiv 43).

## Funcțiile dispozitivului

Șablonul creează 11 dispozitive ModbusElectricityMeter și ModbusVariable, organizate în patru grupuri: senzori de curent pe faze, contoare de energie pe faze, un dispozitiv de energie trifazată totală și contoare de energie pe tarife.

### Monitorizarea curentului pe faze

Trei dispozitive oferă măsurarea curentului în timp real pentru fiecare fază:

- **Curent L1** — curentul fazei 1 (H:22, A), cu tensiunea L1 ca atribut de service (H:14, V)
- **Curent L2** — curentul fazei 2 (H:24, A), cu tensiunea L2 (H:16, V)
- **Curent L3** — curentul fazei 3 (H:26, A), cu tensiunea L3 (H:18, V)

### Măsurarea energiei pe faze

Trei dispozitive urmăresc consumul de energie activă și puterea absorbită pe fiecare fază, cu un set complet de atribute de service:

- **Faza L1** — energia activă totală (H:258, kWh) și puterea activă (H:30, kW). Atributele de service includ tensiunea, curentul, puterea reactivă (kVAr), puterea aparentă (kVA), factorul de putere și contoarele bidirecționale de energie (energie activă și reactivă directă/inversă).
- **Faza L2** — energia activă totală (H:260, kWh) și puterea activă (H:32, kW). Aceleași atribute de service pe fază ca la faza L1.
- **Faza L3** — energia activă totală (H:262, kWh) și puterea activă (H:34, kW). Aceleași atribute de service pe fază ca la faza L1.

### Energia trifazată totală

Un dispozitiv oferă totalurile pentru întregul sistem:

- **Energie totală (3 faze)** — energia activă totală (H:256, kWh) și puterea activă totală absorbită (H:28, kW). Atributele de service includ frecvența rețelei (Hz), puterea reactivă totală (kVAr), puterea aparentă totală (kVA), factorul de putere total și contoarele bidirecționale de energie (energie activă și reactivă directă/inversă).

### Contoare de energie pe tarife

Patru dispozitive urmăresc energia cumulată pe fiecare zonă tarifară (T1–T4):

- **Tarif T1** până la **Tarif T4** — fiecare raportează energia activă totală (kWh), cu atribute de service pentru energia activă directă/inversă și energia reactivă directă/inversă/totală. Contoarele tarifelor urmăresc doar energia cumulată, nu și puterea instantanee absorbită.

Contorul acceptă până la 8 intervale orare pe zi (separat pentru fiecare zi, de luni până duminică) pentru atribuirea zonelor tarifare T1–T4. Programul tarifelor se configurează cu acțiunea de service **Setare tarife**, care permite programarea intervalelor pentru o anumită zi sau pentru toate zilele deodată.

> [!TIP]
> Funcția cu 4 tarife este principala diferență a OR-WE-517 față de OR-WE-516 (care are RS-485, dar nu are programarea tarifelor). OR-WE-513 nu are nici RS-485, nici tarife.

### Acțiuni de service

Șablonul oferă patru acțiuni de service pentru configurarea de la distanță:

- **Dată/oră** — setează ceasul de timp real intern al contorului (an, lună, zi, oră, minute, secunde și ziua săptămânii) prin registrele H:60–H:65
- **Setare tarife** — configurează până la 8 intervale tarifare zilnice (T1–T4) pentru o zi aleasă sau pentru toate zilele deodată, scrise în registrele programului tarifelor începând de la H:768
- **Timp de ciclare LCD** — setează intervalul de derulare automată a afișajului LCD (1–120 secunde)
- **Slave ID** — schimbă adresa Modbus a contorului (1–255) prin registrul holding H:2

### Funcții suplimentare

OR-WE-517 pune la dispoziție și registre pentru energia reactivă totală pe fiecare fază (L1/L2/L3), numărul de serie, versiunea de firmware și de hardware, un cod de configurare combinat și un registru pentru atribuirea tarifelor în sărbători legale și weekend. Acestea pot fi adăugate într-o actualizare viitoare a șablonului.

## Rezolvarea problemelor

### Nu există comunicare

1. Verificați conexiunile bornelor RS-485 A/B — dacă comunicarea nu funcționează, inversați A și B, deoarece marcajele diferă de la un producător la altul
2. Verificați dacă baud rate-ul din TapHome corespunde setării contorului (implicit 9600 bps, vizibil pe pagina 43 a afișajului LCD)
3. Verificați dacă Slave ID-ul corespunde (implicit 1, vizibil pe pagina 42 a afișajului LCD în formatul „Id 255”, unde 255 este adresa curentă)
4. Verificați dacă paritatea este setată la **Even** (8E1) — acest contor folosește implicit paritatea pară, spre deosebire de unele contoare care funcționează implicit fără paritate (8N1)

### Valori citite incorect

1. Asigurați-vă că contorul este conectat ca sistem trifazat cu 4 conductoare, cu toate cele trei faze și nulul trecute prin bornele contorului
2. Pentru măsurarea bidirecțională (energie directă/inversă), verificați dacă sensul transformatorului de curent sau sensul conductorului corespunde sensului fluxului de energie — o conectare inversată face ca energia directă să fie înregistrată ca inversă

### Comunicație prin convertor Ethernet

OR-WE-517 poate fi accesat și printr-un convertor RS-485 – Ethernet (de exemplu Waveshare RS485 to ETH). Când folosiți un astfel de convertor, tipul de protocol trebuie setat la **RTU over TCP** (nu Modbus TCP standard). Formatul de cadru Modbus TCP standard nu funcționează cu acest contor.

## Dispozitive disponibile 11

Aceste dispozitive apar în TapHome după import.

Orno OR-WE-517 Modul

Atribute de service

|                      |                                                                                                                                          |
|----------------------|------------------------------------------------------------------------------------------------------------------------------------------|
| Slave ID             |                                                                                                                                          |
| Baud rate            |                                                                                                                                          |
| Timp de ciclare LCD  |                                                                                                                                          |
| Raport TC            | Raportul transformatorului de curent — se aplică doar contoarelor cu transformatoare de curent, nu și instalațiilor cu conectare directă |
| Constanta ieșirii S0 |                                                                                                                                          |
| Dată și oră          | Data și ora curente din ceasul de timp real intern al contorului                                                                         |
| Tarife (Lu)          |                                                                                                                                          |
| Tarife (Ma)          |                                                                                                                                          |
| Tarife (Mi)          |                                                                                                                                          |
| Tarife (Jo)          |                                                                                                                                          |
| Tarife (Vi)          |                                                                                                                                          |
| Tarife (Sâ)          |                                                                                                                                          |
| Tarife (Du)          |                                                                                                                                          |

Acțiuni de service

|                     |                                                                                                                            |
|---------------------|----------------------------------------------------------------------------------------------------------------------------|
| Dată/oră            | Setează ceasul de timp real intern al contorului — data, ora și ziua săptămânii, pentru funcționarea programului tarifelor |
| Setare tarife       | Configurează până la 8 intervale tarifare zilnice (T1–T4) pentru o zi aleasă sau pentru toate zilele deodată               |
| Slave ID            | Schimbă adresa slave Modbus (1–255) pentru configurații cu mai multe contoare pe magistrala RS-485                         |
| Timp de ciclare LCD | Setează intervalul de derulare automată a afișajului LCD, în secunde                                                       |

Atribute de service

${device\_SlaveId}

```taphome
modbusr(H, 0x02, Uint16)
```

${baud\_rate} \[bps]

```taphome
modbusr(H, 0x03, Uint16)
```

LCD ${cycle\_time} \[s]

```taphome
modbusr(H, 0x0d, Uint16)
```

CT Rate

```taphome
modbusr(H, 0x08, Uint16)
```

S0 output rate \[imp/kWh]

```taphome
modbusr(H, 0x09, Float)
```

${time}

```taphome
var ret := modbusr(H, 0x3c, Uint32);
var ret1 := modbusr(H, 0x3e, Uint16);
var xx := modbusr(H, 0x40, Uint16);
tostring(getbyte(ret,1), "X2") 
+ ":" + tostring(getbyte(ret,2), "X2")
+ ":" + tostring(getbyte(ret,3), "X2")
+ " " + switch(getbyte(ret,0), 
1, "(Mo)",
2, "(Tu)",
3, "(We)",
4, "(Th)",
5, "(Fr)",
6, "(Sa)",
7, "(Su)", "Err")
+ " " + tostring(getbyte(ret1,1), "X2")
+ "." + tostring(getbyte(ret1,0), "X2")
+ ".20" + modbusr(H, 0x3f, LittleEndianUint16);

```

${tariff}s (Mo)

```taphome
var wd1 := modbusr(H, 0x300, Uint32);
var wd2 := modbusr(H, 0x300 +2, Uint32);
var wd3 := modbusr(H, 0x300 +4, Uint32);
var wd4 := modbusr(H, 0x300 +6, Uint32);
var wd5 := modbusr(H, 0x300 +8, Uint32);
var wd6 := modbusr(H, 0x300 +10, Uint32);

var out := "";
if ( getbyte(wd1,1) != 0, out := out +
    "[" + tostring(getbyte(wd1,3), "X2") + ":" + tostring(getbyte(wd1,2), "X2") + "-T" + tostring(getbyte(wd1,1), "X2") + "]" );
if ( getbyte(wd2,2) != 0, out := out +
    "[" + tostring(getbyte(wd1,0), "X2") + ":" + tostring(getbyte(wd2,3), "X2") + "-T" + tostring(getbyte(wd2,2), "X2") + "]" );
if ( getbyte(wd3,3) != 0, out := out +
    "[" + tostring(getbyte(wd2,1), "X2") + ":" + tostring(getbyte(wd2,0), "X2") + "-T" + tostring(getbyte(wd3,3), "X2") + "]" );
if ( getbyte(wd3,0) != 0, out := out +
    "[" + tostring(getbyte(wd3,2), "X2") + ":" + tostring(getbyte(wd3,1), "X2") + "-T" + tostring(getbyte(wd3,0), "X2") + "]" );
if ( getbyte(wd4,1) != 0, out := out +
    "[" + tostring(getbyte(wd4,3), "X2") + ":" + tostring(getbyte(wd4,2), "X2") + "-T" + tostring(getbyte(wd4,1), "X2") + "]" );
if ( getbyte(wd5,2) != 0, out := out +
    "[" + tostring(getbyte(wd4,0), "X2") + ":" + tostring(getbyte(wd5,3), "X2") + "-T" + tostring(getbyte(wd5,2), "X2") + "]" );
if ( getbyte(wd6,3) != 0, out := out +
    "[" + tostring(getbyte(wd5,1), "X2") + ":" + tostring(getbyte(wd5,0), "X2") + "-T" + tostring(getbyte(wd6,3), "X2") + "]" );
if ( getbyte(wd6,0) != 0, out := out +
    "[" + tostring(getbyte(wd6,2), "X2") + ":" + tostring(getbyte(wd6,1), "X2") + "-T" + tostring(getbyte(wd6,0), "X2") + "]" );

return(out)
```

${tariff}s (Tu)

```taphome
var wd1 := modbusr(H, 0x30c, Uint32);
var wd2 := modbusr(H, 0x30c +2, Uint32);
var wd3 := modbusr(H, 0x30c +4, Uint32);
var wd4 := modbusr(H, 0x30c +6, Uint32);
var wd5 := modbusr(H, 0x30c +8, Uint32);
var wd6 := modbusr(H, 0x30c +10, Uint32);

var out := "";
if ( getbyte(wd1,1) != 0, out := out +
    "[" + tostring(getbyte(wd1,3), "X2") + ":" + tostring(getbyte(wd1,2), "X2") + "-T" + tostring(getbyte(wd1,1), "X2") + "]" );
if ( getbyte(wd2,2) != 0, out := out +
    "[" + tostring(getbyte(wd1,0), "X2") + ":" + tostring(getbyte(wd2,3), "X2") + "-T" + tostring(getbyte(wd2,2), "X2") + "]" );
if ( getbyte(wd3,3) != 0, out := out +
    "[" + tostring(getbyte(wd2,1), "X2") + ":" + tostring(getbyte(wd2,0), "X2") + "-T" + tostring(getbyte(wd3,3), "X2") + "]" );
if ( getbyte(wd3,0) != 0, out := out +
    "[" + tostring(getbyte(wd3,2), "X2") + ":" + tostring(getbyte(wd3,1), "X2") + "-T" + tostring(getbyte(wd3,0), "X2") + "]" );
if ( getbyte(wd4,1) != 0, out := out +
    "[" + tostring(getbyte(wd4,3), "X2") + ":" + tostring(getbyte(wd4,2), "X2") + "-T" + tostring(getbyte(wd4,1), "X2") + "]" );
if ( getbyte(wd5,2) != 0, out := out +
    "[" + tostring(getbyte(wd4,0), "X2") + ":" + tostring(getbyte(wd5,3), "X2") + "-T" + tostring(getbyte(wd5,2), "X2") + "]" );
if ( getbyte(wd6,3) != 0, out := out +
    "[" + tostring(getbyte(wd5,1), "X2") + ":" + tostring(getbyte(wd5,0), "X2") + "-T" + tostring(getbyte(wd6,3), "X2") + "]" );
if ( getbyte(wd6,0) != 0, out := out +
    "[" + tostring(getbyte(wd6,2), "X2") + ":" + tostring(getbyte(wd6,1), "X2") + "-T" + tostring(getbyte(wd6,0), "X2") + "]" );

return(out)
```

${tariff}s (We)

```taphome
var wd1 := modbusr(H, 0x318, Uint32);
var wd2 := modbusr(H, 0x318 +2, Uint32);
var wd3 := modbusr(H, 0x318 +4, Uint32);
var wd4 := modbusr(H, 0x318 +6, Uint32);
var wd5 := modbusr(H, 0x318 +8, Uint32);
var wd6 := modbusr(H, 0x318 +10, Uint32);

var out := "";
if ( getbyte(wd1,1) != 0, out := out +
    "[" + tostring(getbyte(wd1,3), "X2") + ":" + tostring(getbyte(wd1,2), "X2") + "-T" + tostring(getbyte(wd1,1), "X2") + "]" );
if ( getbyte(wd2,2) != 0, out := out +
    "[" + tostring(getbyte(wd1,0), "X2") + ":" + tostring(getbyte(wd2,3), "X2") + "-T" + tostring(getbyte(wd2,2), "X2") + "]" );
if ( getbyte(wd3,3) != 0, out := out +
    "[" + tostring(getbyte(wd2,1), "X2") + ":" + tostring(getbyte(wd2,0), "X2") + "-T" + tostring(getbyte(wd3,3), "X2") + "]" );
if ( getbyte(wd3,0) != 0, out := out +
    "[" + tostring(getbyte(wd3,2), "X2") + ":" + tostring(getbyte(wd3,1), "X2") + "-T" + tostring(getbyte(wd3,0), "X2") + "]" );
if ( getbyte(wd4,1) != 0, out := out +
    "[" + tostring(getbyte(wd4,3), "X2") + ":" + tostring(getbyte(wd4,2), "X2") + "-T" + tostring(getbyte(wd4,1), "X2") + "]" );
if ( getbyte(wd5,2) != 0, out := out +
    "[" + tostring(getbyte(wd4,0), "X2") + ":" + tostring(getbyte(wd5,3), "X2") + "-T" + tostring(getbyte(wd5,2), "X2") + "]" );
if ( getbyte(wd6,3) != 0, out := out +
    "[" + tostring(getbyte(wd5,1), "X2") + ":" + tostring(getbyte(wd5,0), "X2") + "-T" + tostring(getbyte(wd6,3), "X2") + "]" );
if ( getbyte(wd6,0) != 0, out := out +
    "[" + tostring(getbyte(wd6,2), "X2") + ":" + tostring(getbyte(wd6,1), "X2") + "-T" + tostring(getbyte(wd6,0), "X2") + "]" );

return(out)
```

${tariff}s (Th)

```taphome
var wd1 := modbusr(H, 0x324, Uint32);
var wd2 := modbusr(H, 0x324 +2, Uint32);
var wd3 := modbusr(H, 0x324 +4, Uint32);
var wd4 := modbusr(H, 0x324 +6, Uint32);
var wd5 := modbusr(H, 0x324 +8, Uint32);
var wd6 := modbusr(H, 0x324 +10, Uint32);

var out := "";
if ( getbyte(wd1,1) != 0, out := out +
    "[" + tostring(getbyte(wd1,3), "X2") + ":" + tostring(getbyte(wd1,2), "X2") + "-T" + tostring(getbyte(wd1,1), "X2") + "]" );
if ( getbyte(wd2,2) != 0, out := out +
    "[" + tostring(getbyte(wd1,0), "X2") + ":" + tostring(getbyte(wd2,3), "X2") + "-T" + tostring(getbyte(wd2,2), "X2") + "]" );
if ( getbyte(wd3,3) != 0, out := out +
    "[" + tostring(getbyte(wd2,1), "X2") + ":" + tostring(getbyte(wd2,0), "X2") + "-T" + tostring(getbyte(wd3,3), "X2") + "]" );
if ( getbyte(wd3,0) != 0, out := out +
    "[" + tostring(getbyte(wd3,2), "X2") + ":" + tostring(getbyte(wd3,1), "X2") + "-T" + tostring(getbyte(wd3,0), "X2") + "]" );
if ( getbyte(wd4,1) != 0, out := out +
    "[" + tostring(getbyte(wd4,3), "X2") + ":" + tostring(getbyte(wd4,2), "X2") + "-T" + tostring(getbyte(wd4,1), "X2") + "]" );
if ( getbyte(wd5,2) != 0, out := out +
    "[" + tostring(getbyte(wd4,0), "X2") + ":" + tostring(getbyte(wd5,3), "X2") + "-T" + tostring(getbyte(wd5,2), "X2") + "]" );
if ( getbyte(wd6,3) != 0, out := out +
    "[" + tostring(getbyte(wd5,1), "X2") + ":" + tostring(getbyte(wd5,0), "X2") + "-T" + tostring(getbyte(wd6,3), "X2") + "]" );
if ( getbyte(wd6,0) != 0, out := out +
    "[" + tostring(getbyte(wd6,2), "X2") + ":" + tostring(getbyte(wd6,1), "X2") + "-T" + tostring(getbyte(wd6,0), "X2") + "]" );

return(out)
```

${tariff}s (Fr)

```taphome
var wd1 := modbusr(H, 0x330, Uint32);
var wd2 := modbusr(H, 0x330 +2, Uint32);
var wd3 := modbusr(H, 0x330 +4, Uint32);
var wd4 := modbusr(H, 0x330 +6, Uint32);
var wd5 := modbusr(H, 0x330 +8, Uint32);
var wd6 := modbusr(H, 0x330 +10, Uint32);

var out := "";
if ( getbyte(wd1,1) != 0, out := out +
    "[" + tostring(getbyte(wd1,3), "X2") + ":" + tostring(getbyte(wd1,2), "X2") + "-T" + tostring(getbyte(wd1,1), "X2") + "]" );
if ( getbyte(wd2,2) != 0, out := out +
    "[" + tostring(getbyte(wd1,0), "X2") + ":" + tostring(getbyte(wd2,3), "X2") + "-T" + tostring(getbyte(wd2,2), "X2") + "]" );
if ( getbyte(wd3,3) != 0, out := out +
    "[" + tostring(getbyte(wd2,1), "X2") + ":" + tostring(getbyte(wd2,0), "X2") + "-T" + tostring(getbyte(wd3,3), "X2") + "]" );
if ( getbyte(wd3,0) != 0, out := out +
    "[" + tostring(getbyte(wd3,2), "X2") + ":" + tostring(getbyte(wd3,1), "X2") + "-T" + tostring(getbyte(wd3,0), "X2") + "]" );
if ( getbyte(wd4,1) != 0, out := out +
    "[" + tostring(getbyte(wd4,3), "X2") + ":" + tostring(getbyte(wd4,2), "X2") + "-T" + tostring(getbyte(wd4,1), "X2") + "]" );
if ( getbyte(wd5,2) != 0, out := out +
    "[" + tostring(getbyte(wd4,0), "X2") + ":" + tostring(getbyte(wd5,3), "X2") + "-T" + tostring(getbyte(wd5,2), "X2") + "]" );
if ( getbyte(wd6,3) != 0, out := out +
    "[" + tostring(getbyte(wd5,1), "X2") + ":" + tostring(getbyte(wd5,0), "X2") + "-T" + tostring(getbyte(wd6,3), "X2") + "]" );
if ( getbyte(wd6,0) != 0, out := out +
    "[" + tostring(getbyte(wd6,2), "X2") + ":" + tostring(getbyte(wd6,1), "X2") + "-T" + tostring(getbyte(wd6,0), "X2") + "]" );

return(out)
```

${tariff}s (Sa)

```taphome
var wd1 := modbusr(H, 0x33c, Uint32);
var wd2 := modbusr(H, 0x33c +2, Uint32);
var wd3 := modbusr(H, 0x33c +4, Uint32);
var wd4 := modbusr(H, 0x33c +6, Uint32);
var wd5 := modbusr(H, 0x33c +8, Uint32);
var wd6 := modbusr(H, 0x33c +10, Uint32);

var out := "";
if ( getbyte(wd1,1) != 0, out := out +
    "[" + tostring(getbyte(wd1,3), "X2") + ":" + tostring(getbyte(wd1,2), "X2") + "-T" + tostring(getbyte(wd1,1), "X2") + "]" );
if ( getbyte(wd2,2) != 0, out := out +
    "[" + tostring(getbyte(wd1,0), "X2") + ":" + tostring(getbyte(wd2,3), "X2") + "-T" + tostring(getbyte(wd2,2), "X2") + "]" );
if ( getbyte(wd3,3) != 0, out := out +
    "[" + tostring(getbyte(wd2,1), "X2") + ":" + tostring(getbyte(wd2,0), "X2") + "-T" + tostring(getbyte(wd3,3), "X2") + "]" );
if ( getbyte(wd3,0) != 0, out := out +
    "[" + tostring(getbyte(wd3,2), "X2") + ":" + tostring(getbyte(wd3,1), "X2") + "-T" + tostring(getbyte(wd3,0), "X2") + "]" );
if ( getbyte(wd4,1) != 0, out := out +
    "[" + tostring(getbyte(wd4,3), "X2") + ":" + tostring(getbyte(wd4,2), "X2") + "-T" + tostring(getbyte(wd4,1), "X2") + "]" );
if ( getbyte(wd5,2) != 0, out := out +
    "[" + tostring(getbyte(wd4,0), "X2") + ":" + tostring(getbyte(wd5,3), "X2") + "-T" + tostring(getbyte(wd5,2), "X2") + "]" );
if ( getbyte(wd6,3) != 0, out := out +
    "[" + tostring(getbyte(wd5,1), "X2") + ":" + tostring(getbyte(wd5,0), "X2") + "-T" + tostring(getbyte(wd6,3), "X2") + "]" );
if ( getbyte(wd6,0) != 0, out := out +
    "[" + tostring(getbyte(wd6,2), "X2") + ":" + tostring(getbyte(wd6,1), "X2") + "-T" + tostring(getbyte(wd6,0), "X2") + "]" );

return(out)
```

${tariff}s (Su)

```taphome
var wd1 := modbusr(H, 0x348, Uint32);
var wd2 := modbusr(H, 0x348 +2, Uint32);
var wd3 := modbusr(H, 0x348 +4, Uint32);
var wd4 := modbusr(H, 0x348 +6, Uint32);
var wd5 := modbusr(H, 0x348 +8, Uint32);
var wd6 := modbusr(H, 0x348 +10, Uint32);

var out := "";
if ( getbyte(wd1,1) != 0, out := out +
    "[" + tostring(getbyte(wd1,3), "X2") + ":" + tostring(getbyte(wd1,2), "X2") + "-T" + tostring(getbyte(wd1,1), "X2") + "]" );
if ( getbyte(wd2,2) != 0, out := out +
    "[" + tostring(getbyte(wd1,0), "X2") + ":" + tostring(getbyte(wd2,3), "X2") + "-T" + tostring(getbyte(wd2,2), "X2") + "]" );
if ( getbyte(wd3,3) != 0, out := out +
    "[" + tostring(getbyte(wd2,1), "X2") + ":" + tostring(getbyte(wd2,0), "X2") + "-T" + tostring(getbyte(wd3,3), "X2") + "]" );
if ( getbyte(wd3,0) != 0, out := out +
    "[" + tostring(getbyte(wd3,2), "X2") + ":" + tostring(getbyte(wd3,1), "X2") + "-T" + tostring(getbyte(wd3,0), "X2") + "]" );
if ( getbyte(wd4,1) != 0, out := out +
    "[" + tostring(getbyte(wd4,3), "X2") + ":" + tostring(getbyte(wd4,2), "X2") + "-T" + tostring(getbyte(wd4,1), "X2") + "]" );
if ( getbyte(wd5,2) != 0, out := out +
    "[" + tostring(getbyte(wd4,0), "X2") + ":" + tostring(getbyte(wd5,3), "X2") + "-T" + tostring(getbyte(wd5,2), "X2") + "]" );
if ( getbyte(wd6,3) != 0, out := out +
    "[" + tostring(getbyte(wd5,1), "X2") + ":" + tostring(getbyte(wd5,0), "X2") + "-T" + tostring(getbyte(wd6,3), "X2") + "]" );
if ( getbyte(wd6,0) != 0, out := out +
    "[" + tostring(getbyte(wd6,2), "X2") + ":" + tostring(getbyte(wd6,1), "X2") + "-T" + tostring(getbyte(wd6,0), "X2") + "]" );

return(out)
```

Acțiuni de service

Date/Time

Parametri: Year (22–99 YY), Month (1–12 MM), Day (1–31 DD), Hour (1–24 HH), Minutes (0–59 MI), Seconds (0–59 SS), Day of Week

```taphome
var out1 := (tobcd(MI) << 8) + tobcd(SS);
var out2 := (tobcd(DW) << 8) + tobcd(HH);
var out3 := (tobcd(MM) << 8) + tobcd(DD);

modbusw(H, 0x3c, LittleEndianUint16, out1, out2, out3, YY);
```

${set\_tarriffs}

Parametri: Interval 1 - ${hour} (0–23 HH1), Interval 1 - ${minutes} (0–59 MI1), Interval 1 - ${tariff} (0–4 T1), Interval 2 - Hour (0–23 HH2), Interval 2 - Minutes (0–59 MI2), Interval 2 - ${tariff} (0–4 T2), Interval 3 - Hour (0–23 HH3), Interval 3 - Minutes (0–59 MI3), Interval 3 - ${tariff} (0–4 T3), Interval 4 - Hour (0–23 HH4), Interval 4 - Minutes (0–59 MI4), Interval 4 - ${tariff} (0–4 T4), Interval 5 - Hour (0–23 HH5), Interval 5 - Minutes (0–59 MI5), Interval 5 - ${tariff} (0–4 T5), Interval 6 - Hour (0–23 HH6), Interval 6 - Minutes (0–59 MI6), Interval 6 - ${tariff} (0–4 T6), Interval 7 - Hour (0–23 HH7), Interval 7 - Minutes (0–59 MI7), Interval 7 - ${tariff} (0–4 T7), Interval 8 - Hour (0–23 HH8), Interval 8 - Minutes (0–59 MI8), Interval 8 - ${tariff} (0–4 T8), Day

```taphome
var wd1 := (tobcd(HH1) << 24) + (tobcd(MI1) << 16) + (tobcd(T1) << 8) + tobcd(HH2);
var wd2 := (tobcd(MI2) << 24) + (tobcd(T2) << 16) + (tobcd(HH3) << 8) + tobcd(MI3);
var wd3 := (tobcd(T3) << 24) + (tobcd(HH4) << 16) + (tobcd(MI4) << 8) + tobcd(T4);
var wd4 := (tobcd(HH5) << 24) + (tobcd(MI5) << 16) + (tobcd(T5) << 8) + tobcd(HH6);
var wd5 := (tobcd(MI6) << 24) + (tobcd(T6) << 16) + (tobcd(HH7) << 8) + tobcd(MI7);
var wd6 := (tobcd(T7) << 24) + (tobcd(HH8) << 16) + (tobcd(MI8) << 8) + tobcd(T8);

if DoW = 0 or DoW = 1
    modbusw(H, 0x300, Uint32, wd1, wd2, wd3, wd4, wd5, wd6);
end
if DoW = 0 or DoW = 2
    modbusw(H, 0x30c, Uint32, wd1, wd2, wd3, wd4, wd5, wd6);
end
if DoW = 0 or DoW = 3
    modbusw(H, 0x318, Uint32, wd1, wd2, wd3, wd4, wd5, wd6);
end
if DoW = 0 or DoW = 4
    modbusw(H, 0x324, Uint32, wd1, wd2, wd3, wd4, wd5, wd6);
end
if DoW = 0 or DoW = 5
    modbusw(H, 0x330, Uint32, wd1, wd2, wd3, wd4, wd5, wd6);
end
if DoW = 0 or DoW = 6
    modbusw(H, 0x33c, Uint32, wd1, wd2, wd3, wd4, wd5, wd6);
end
if DoW = 0 or DoW = 7
    modbusw(H, 0x348, Uint32, wd1, wd2, wd3, wd4, wd5, wd6);
end
```

Slave ID

Parametri: Parameter1 (1–255 ID)

```taphome
modbusw(H, 0x02, Uint16, ID)
```

LCD Cycle time

Parametri: Time \[s] (1–120 t)

```taphome
modbusw(H, 0x0d, Uint16, t)
```

Curent L1 Variabilă Doar citire

Registru: H:22 Float Unitate: A

Atribute de service

|             |
|-------------|
| Tensiune L1 |

Citire

```taphome
MODBUSR(H, 22, Float)
```

Atribute de service

L1 ${electric\_voltage} \[V]

```taphome
round(modbusr(H, 0x0e, Float)*10)/10
```

Curent L2 Variabilă Doar citire

Registru: H:24 Float Unitate: A

Atribute de service

|             |
|-------------|
| Tensiune L2 |

Citire

```taphome
MODBUSR(H, 24, Float)
```

Atribute de service

L2 ${electric\_voltage} \[V]

```taphome
round(modbusr(H, 0x10, Float)*10)/10
```

Curent L3 Variabilă Doar citire

Registru: H:26 Float Unitate: A

Atribute de service

|             |
|-------------|
| Tensiune L3 |

Citire

```taphome
MODBUSR(H, 26, Float)
```

Atribute de service

L3 ${electric\_voltage} \[V]

```taphome
round(modbusr(H, 0x12, Float)*10)/10
```

Faza L1 Contor electric Doar citire

Contor de energie pentru faza 1 — energia activă totală și puterea activă, cu tensiune, curent, putere reactivă/aparentă, factor de putere și contoare bidirecționale de energie

Registru: H:258 (readtotalconsumption), H:30 (readdemand) Float Unitate: kWh / kW

Atribute de service

|                          |
|--------------------------|
| Tensiune                 |
| Curent                   |
| Putere reactivă          |
| Putere aparentă          |
| Factor de putere         |
| Energie activă directă   |
| Energie activă inversă   |
| Energie reactivă directă |
| Energie reactivă inversă |

Citirea consumului total

```taphome
MODBUSR(H, 0x102, Float)
```

Citirea cererii

```taphome
MODBUSR(H, 0x1e, Float)
```

Atribute de service

${electric\_voltage} \[V]

```taphome
tostring(modbusr(H, 0x0e,Float), "F2")
```

${electric\_current} \[A]

```taphome
tostring(modbusr(H, 0x16,Float), "F2")
```

${reactive\_power} \[kVAr]

```taphome
tostring(modbusr(H, 0x26,Float), "F2")
```

${apparent\_power} \[kVA]

```taphome
tostring(modbusr(H, 0x2e,Float), "F2")
```

${power\_factor}

```taphome
tostring(modbusr(H, 0x36,Float), "F2")
```

${forward\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x10a,Float), "F2")
```

${reverse\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x112,Float), "F2")
```

${forward\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x122,Float), "F2")
```

${reverse\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x12a,Float), "F2")
```

Faza L2 Contor electric Doar citire

Registru: H:260 (readtotalconsumption), H:32 (readdemand) Float Unitate: kWh / kW

Atribute de service

|                          |
|--------------------------|
| Tensiune                 |
| Curent                   |
| Putere reactivă          |
| Putere aparentă          |
| Factor de putere         |
| Energie activă directă   |
| Energie activă inversă   |
| Energie reactivă directă |
| Energie reactivă inversă |

Citirea consumului total

```taphome
MODBUSR(H, 0x104, Float)
```

Citirea cererii

```taphome
MODBUSR(H, 0x20, Float)
```

Atribute de service

${electric\_voltage} \[V]

```taphome
tostring(modbusr(H, 0x10,Float), "F2")
```

${electric\_current} \[A]

```taphome
tostring(modbusr(H, 0x18,Float), "F2")
```

${reactive\_power} \[kVAr]

```taphome
tostring(modbusr(H, 0x28,Float), "F2")
```

${apparent\_power} \[kVA]

```taphome
tostring(modbusr(H, 0x30,Float), "F2")
```

${power\_factor}

```taphome
tostring(modbusr(H, 0x38,Float), "F2")
```

${forward\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x10c,Float), "F2")
```

${reverse\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x114,Float), "F2")
```

${forward\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x124,Float), "F2")
```

${reverse\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x12c,Float), "F2")
```

Faza L3 Contor electric Doar citire

Registru: H:262 (readtotalconsumption), H:34 (readdemand) Float Unitate: kWh / kW

Atribute de service

|                          |
|--------------------------|
| Tensiune                 |
| Curent                   |
| Putere reactivă          |
| Putere aparentă          |
| Factor de putere         |
| Energie activă directă   |
| Energie activă inversă   |
| Energie reactivă directă |
| Energie reactivă inversă |

Citirea consumului total

```taphome
MODBUSR(H, 0x106, Float)
```

Citirea cererii

```taphome
MODBUSR(H, 0x22, Float)
```

Atribute de service

${electric\_voltage} \[V]

```taphome
tostring(modbusr(H, 0x12,Float), "F2")
```

${electric\_current} \[A]

```taphome
tostring(modbusr(H, 0x1a,Float), "F2")
```

${reactive\_power} \[kVAr]

```taphome
tostring(modbusr(H, 0x2a,Float), "F2")
```

${apparent\_power} \[kVA]

```taphome
tostring(modbusr(H, 0x32,Float), "F2")
```

${power\_factor}

```taphome
tostring(modbusr(H, 0x3a,Float), "F2")
```

${forward\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x10e,Float), "F2")
```

${reverse\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x116,Float), "F2")
```

${forward\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x126,Float), "F2")
```

${reverse\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x12e,Float), "F2")
```

Tarif T1 Contor electric Doar citire

Contor de energie cumulată pentru tariful 1 — energia activă totală, cu defalcarea energiei active și reactive directe/inverse

Registru: H:304 (readtotalconsumption) Float Unitate: kWh

Atribute de service

|                          |
|--------------------------|
| Energie activă directă   |
| Energie activă inversă   |
| Energie reactivă totală  |
| Energie reactivă directă |
| Energie reactivă inversă |

Citirea consumului total

```taphome
MODBUSR(H, 0x130, Float)
```

Atribute de service

${forward\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x132,Float), "F2")
```

${reverse\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x134,Float), "F2")
```

${total\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x136,Float), "F2")
```

${forward\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x138,Float), "F2")
```

${reverse\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x13a,Float), "F2")
```

Tarif T2 Contor electric Doar citire

Registru: H:316 (readtotalconsumption) Float Unitate: kWh

Atribute de service

|                          |
|--------------------------|
| Energie activă directă   |
| Energie activă inversă   |
| Energie reactivă totală  |
| Energie reactivă directă |
| Energie reactivă inversă |

Citirea consumului total

```taphome
MODBUSR(H, 0x13c, Float)
```

Atribute de service

${forward\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x13e,Float), "F2")
```

${reverse\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x140,Float), "F2")
```

${total\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x142,Float), "F2")
```

${forward\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x144,Float), "F2")
```

${reverse\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x146,Float), "F2")
```

Tarif T3 Contor electric Doar citire

Registru: H:328 (readtotalconsumption) Float Unitate: kWh

Atribute de service

|                          |
|--------------------------|
| Energie activă directă   |
| Energie activă inversă   |
| Energie reactivă totală  |
| Energie reactivă directă |
| Energie reactivă inversă |

Citirea consumului total

```taphome
MODBUSR(H, 0x148, Float)
```

Atribute de service

${forward\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x14a,Float), "F2")
```

${reverse\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x14c,Float), "F2")
```

${total\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x14e,Float), "F2")
```

${forward\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x150,Float), "F2")
```

${reverse\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x152,Float), "F2")
```

Tarif T4 Contor electric Doar citire

Registru: H:340 (readtotalconsumption) Float Unitate: kWh

Atribute de service

|                          |
|--------------------------|
| Energie activă directă   |
| Energie activă inversă   |
| Energie reactivă totală  |
| Energie reactivă directă |
| Energie reactivă inversă |

Citirea consumului total

```taphome
MODBUSR(H, 0x154, Float)
```

Atribute de service

${forward\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x156,Float), "F2")
```

${reverse\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x158,Float), "F2")
```

${total\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x15a,Float), "F2")
```

${forward\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x15c,Float), "F2")
```

${reverse\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x15e,Float), "F2")
```

Energie totală (3 faze) Contor electric Doar citire

Total pentru sistemul trifazat — energia activă și puterea absorbită, cu frecvența rețelei, putere reactivă/aparentă, factor de putere și contoare bidirecționale de energie

Registru: H:256 (readtotalconsumption), H:28 (readdemand) Float Unitate: kWh / kW

Atribute de service

|                          |
|--------------------------|
| Frecvența rețelei        |
| Putere reactivă totală   |
| Putere aparentă totală   |
| Factor de putere total   |
| Energie activă directă   |
| Energie activă inversă   |
| Energie reactivă directă |
| Energie reactivă inversă |

Citirea consumului total

```taphome
MODBUSR(H, 0x100, Float)
```

Citirea cererii

```taphome
MODBUSR(H, 0x1c, Float)
```

Atribute de service

${grid\_frequency} \[Hz]

```taphome
tostring(modbusr(H, 0x14,Float), "F2")
```

${reactive\_power} \[kVAr]

```taphome
tostring(modbusr(H, 0x24,Float), "F2")
```

${apparent\_power} \[kVA]

```taphome
tostring(modbusr(H, 0x2c,Float), "F2")
```

${power\_factor}

```taphome
tostring(modbusr(H, 0x34,Float), "F2")
```

${forward\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x108,Float), "F2")
```

${reverse\_active\_energy} \[kWh]

```taphome
tostring(modbusr(H, 0x110,Float), "F2")
```

${forward\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x120,Float), "F2")
```

${reverse\_reactive\_energy} \[kVArh]

```taphome
tostring(modbusr(H, 0x128,Float), "F2")
```

**Conexiune:** Modbus RTU • 9600 baud• 8E1 • Slave ID: $\[SlaveId]

Îmbunătățiri posibile (9)

- H:280 Total Reactive Energy — Aggregate reactive energy counter (sum of all phases)
- H:282 L1 Reactive Energy — Per-phase reactive energy — only forward/reverse reactive exposed, not total per-phase
- H:284 L2 Reactive Energy — Per-phase reactive energy
- H:286 L3 Reactive Energy — Per-phase reactive energy
- H:0 Serial Number — 4-byte serial number, read-only
- H:4 Software Version — Firmware version as float
- H:6 Hardware Version — Hardware version as float
- H:11 Combined Code — Configuration code, R/W
- H:12 HOLIDAY-WEEKEND T — Holiday/weekend tariff assignment

## Parametri de import

Introduceți aceste valori când importați XML-ul.

| Solicitat în aplicație | Implicit      |
|------------------------|---------------|
| Slave ID               | `1`           |
| Adresă IP              | `192.168.1.0` |

## Surse

- Orno OR-WE-517 Modbus Register Map
  
  2026-03-27
  
  [PDF](https://taphome.com/compatibility/devices/orno-or-we-517/manufacturer/Orno%20OR-WE-517.pdf)
- OR-WE-513/516/517 Installation Manual
  
  [files.orno.pl](https://files.orno.pl/manuals/OR-WE-513,516,517_manual_EN.pdf) 2026-03-27
  
  [PDF](https://taphome.com/compatibility/devices/orno-or-we-517/manufacturer/installation-manual.pdf)
- Home Assistant Community — OR-WE-517 Modbus Configuration
  
  [community.home-assistant.io](https://community.home-assistant.io/t/configuration-of-the-orno-or-we-517-three-phase-meter-waveshare-rs485-to-eth-converter/778679) 2026-03-27

Documentele producătorilor sunt © ale proprietarilor respectivi. Sunt furnizate așa cum au fost publicate de producător, doar ca referință.

## Documentație asociată

- [Modbus Integration](https://taphome.com/ro/compatibility/modbus-guide/)
- [Modbus](https://taphome.com/ro/docs/integration/modbus/)
- [Configurare simplă cu ajutorul șabloanelor](https://taphome.com/ro/docs/integration/modbus/templates/)
- [Scripturi Modbus și prefetch](https://taphome.com/ro/docs/script/modbus-scripts/)
- [Funcții Modbus](https://taphome.com/ro/docs/script/modbus/)
- [Tipuri de date Modbus](https://taphome.com/ro/docs/script/modbus-data-types/)

