For those interested, this is what an energy meter on 3x 230V without N is reporting.
Phase power and total power are reported on different addresses. So, not calculated here.
To me, it does not make sense.
PS: V on L2 is not reported. This is how meter works.
And while injecting:
Personally, I can’t get it.
However, for what I need to do, total power is the one to follow.
Got some help via AI. So, it is possible to use ESP32 instead of EM540.
Also, Mp2- GX can be connected in the 3x230V network. It does work.
Since my last comment, I’ve purchased the MP-2 GX, NKON 16K batteries and an MPPT250/70. All installed and connected.
Now I wait for EM540 to connect and have all running. (Seems getting all up and running faster.) I’ve started the system based on external current trafo, but it does not give good results due to induced currents from other phases / consumers.
Later I will study the Arduino emulation.
PS. I have some doubts on phase sequence in the house (3x230V). Seams wrong. Expecting a rotation phase tester to be sure and correct if needed.
Project up and running.
Setup:
Advantage:
Upcoming: Taking data from MP-2 in ESP32 to have hot water boiler control with remaining energy or with energy from battery, if next day would be sunny.
Below how it looks like.
Set as indicated: Settings.pdf (964.5 KB)
It looks like I need to do the Arduino implementation, as Multiplus does write over Modbus in EM540 and is resetting saved parameters. Mainly at restart of Multiplus. That is very annoying.
So, topic to be continued.
And here some progress.
This is how it did look before a network of 3x230 without neutral, from the perspective of Multiplus-2 GX.
And this is how it looks like after is being processed.
You can see that voltages are changed. Power on L2 is zero.
Would it be it?
I still need to document all of it.
Here is full documented project, including parts.
It does work for me. I can’t promise anything for any other’s aplication.
Keep in mind that everthing below is AI generated. Use on your own responsability.
SYSTEM SPECIFICATION & PRODUCTION MANUAL
Project Target: Interfacing a Carlo Gavazzi EM540 Energy Meter with a Victron MultiPlus-II GX on a Belgian 3x230V Delta Grid (No Neutral) using an ESP32.
1. Hardware Architecture & Bill of Materials (BOM)
| Component Description [1, 2] | Quantity | Purpose | Specific Requirement / Notes |
|---|---|---|---|
| ESP32 Development Board | 1 | System Core Processor | Standard 30-pin or 38-pin ESP32 (NodeMCU style). |
| DollaTek TTL to RS485 Converter | 1 | Bus 2 (Victron Interface) | Natively compatible with 3.3V/5V logic. Contains onboard RXD/TXD diagnostic LEDs. Automatic direction switching. |
| Fasizi TTL to RS485 Module | 1 | Bus 1 (Physical Meter Interface) | 5V MCU module with manual DE/RE direction switching control. |
| JZK USB-to-RS485 Adapter | 1 | Serial Media Converter | Plugged into the isolated side of the ADuM3160 to bridge the RS485 differential wires. |
| ADuM3160 USB Voltage Isolator | 1 | Hardware Signal Protection | Mandatory Protection. Placed between the MultiPlus-II GX USB port and the JZK adapter. Breaks ground loops up to 2500V. Must be set manually via onboard jumper to Full Speed (12Mbps). |
| Carlo Gavazzi EM540 | 1 | Physical Grid Energy Meter | Hard-configured to Slave ID 3 and 115200 Baud Rate. |
| Victron MultiPlus-II GX | 1 | Inverter/Charger System Core | Running Venus OS, expecting Grid Meter on Slave ID 1 via USB. |
2. Complete Physical Wiring Blueprint & Conditioning Networks
Bus 1: Master Loop (ESP32 ⇄ Physical EM540 Meter)
Driven via the 5V Fasizi Module with integrated hardware level-matching protection.
A+ to A+, B- to B-, GND to shared signal ground).Bus 2: Slave Loop (ESP32 ⇄ Victron MultiPlus-II GX via Isolator)
Driven via the native 3.3V/5V buffered DollaTek Module and fully protected by galvanic isolation. [1]
A to A+, B to B-).
3. System Hazards & Critical Design Warnings
USB Voltage Isolator (ADuM3160) Speed & Power Constraints
4. Real-Time Data Manipulation Logic (Belgian Delta Mapping)
To substitute an explicit physical neutral wire for the MultiPlus-II GX system engine, Phase L2 is treated as a Virtual Neutral (0.0V). To prevent losing the energy calculation contribution from Phase L2, its active power is split evenly between the remaining two virtual active lines monitored by the Victron ESS loop.
\(\text{Manipulated\ }V_{L1-N}=\text{True\ Line\ }V_{L1-L2}\)
\(\text{Manipulated\ }V_{L2-N}=0.0\text{V\ (Virtual\ Neutral\ Target)}\)
\(\text{Manipulated\ }V_{L3-N}=\text{True\ Line\ }V_{L3-L2}\)
\(\text{Manipulated\ }P_{L1}=\text{Real\ }P_{L1}+\left(\frac{\text{Real\ }P_{L2}}{2}\right)\)
\(\text{Manipulated\ }P_{L2}=0.0\text{W}\)
\(\text{Manipulated\ }P_{L3}=\text{Real\ }P_{L3}+\left(\frac{\text{Real\ }P_{L2}}{2}\right)\)
\(\text{Reported\ Net\ System\ Active\ Power}=\text{Real\ }P_{L1}+\text{Real\ }P_{L2}+\text{Real\ }P_{L3}\)
5. Final Verified Production Firmware Layout
#include <ModbusRTU.h> // by Alexander Emelianov
#include <HardwareSerial.h>
// =========================================================================
// HARDWARE PIN CONFIGURATIONS
// =========================================================================
#define METER_RX 16 // RO pin on Protected Fasizi Module 1
#define METER_TX 17 // DI pin on Protected Fasizi Module 1
#define METER_DE_RE 4 // RE/DE jumper pin on Fasizi Module 1
#define EM540_SLAVE_ID 3 // Physical meter set to Slave ID 3
#define GX_RX 26 // RXD pin on Direct DollaTek Module 2
#define GX_TX 27 // TXD pin on Direct DollaTek Module 2
#define VICTRON_SLAVE_ID 1 // MultiPlus expects Grid Meter on Slave ID 1
ModbusRTU mbBus1; // Master Engine (Bus 1)
ModbusRTU mbBus2; // Slave Engine (Bus 2)
HardwareSerial SerialMeter(2);
HardwareSerial SerialGX(1);
// =========================================================================
// BUS 1 HIGH-SPEED EXTRACTION BUFFER
// =========================================================================
uint16_t extLiveBlock[24]; // Holds 0x0000 to 0x0017 contiguously
uint16_t extPhasePF[3]; // 0x002E to 0x0030
uint16_t extFreqSeq[2]; // 0x0032 to 0x0033
uint16_t extEnergy[2]; // 0x0034 to 0x0035
volatile bool bus1JobDone = true;
unsigned long lastFastPoll = 0;
unsigned long lastSlowPoll = 0;
uint8_t slowState = 0;
int32_t getInt32(uint16_t* buffer, uint8_t index) {
return (int32_t)(((uint32_t)buffer[index + 1] << 16) | buffer[index]);
}
bool cbMasterFinished(Modbus::ResultCode event, uint16_t transactionId, void* data) {
bus1JobDone = true;
return true;
}
void allocateRegisterBlock(uint16_t startAddr, uint16_t numRegs) {
for (uint16_t i = 0; i < numRegs; i++) {
mbBus2.addHreg(startAddr + i, 0x0000);
mbBus2.addIreg(startAddr + i, 0x0000);
}
}
void injectInt32IntoBus2(uint16_t targetAddress, int32_t value) {
uint16_t lowWord = (uint16_t)(value & 0xFFFF);
uint16_t highWord = (uint16_t)((value >> 16) & 0xFFFF);
mbBus2.Hreg(targetAddress, lowWord);
mbBus2.Ireg(targetAddress, lowWord);
mbBus2.Hreg(targetAddress + 1, highWord);
mbBus2.Ireg(targetAddress + 1, highWord);
}
void preLoadStaticHandshakeConstants() {
allocateRegisterBlock(0x0000, 290);
allocateRegisterBlock(0x0300, 32);
allocateRegisterBlock(0x0530, 16);
allocateRegisterBlock(0x1000, 6);
allocateRegisterBlock(0x1100, 6);
allocateRegisterBlock(0x5000, 12);
mbBus2.Hreg(0x000B, 1760); mbBus2.Ireg(0x000B, 1760);
mbBus2.Hreg(0x0024, 0x0554); mbBus2.Ireg(0x0024, 0x0554);
mbBus2.Hreg(0x0026, 0x0009); mbBus2.Ireg(0x0026, 0x0009);
mbBus2.Hreg(0x0040, 0x006F); mbBus2.Ireg(0x0040, 0x006F);
mbBus2.Hreg(0x0044, 0x080B); mbBus2.Ireg(0x0044, 0x080B);
mbBus2.Hreg(0x004E, 0x14B1); mbBus2.Ireg(0x004E, 0x14B1);
mbBus2.Hreg(0x010E, 0x0000); mbBus2.Ireg(0x010E, 0x0000);
mbBus2.Hreg(0x1002, 0x0000); mbBus2.Ireg(0x1002, 0x0000);
mbBus2.Hreg(0x0302, 0x1403); mbBus2.Ireg(0x0302, 0x1403);
uint16_t s1 = 0x4B58; uint16_t s2 = 0x3131; uint16_t s3 = 0x3830;
uint16_t s4 = 0x3033; uint16_t s5 = 0x3030; uint16_t s6 = 0x3031; uint16_t s7 = 0x4100;
mbBus2.Hreg(0x0304, s1); mbBus2.Ireg(0x0304, s1); mbBus2.Hreg(0x0305, s2); mbBus2.Ireg(0x0305, s2);
mbBus2.Hreg(0x0306, s3); mbBus2.Ireg(0x0306, s3); mbBus2.Hreg(0x0307, s4); mbBus2.Ireg(0x0307, s4);
mbBus2.Hreg(0x0308, s5); mbBus2.Ireg(0x0308, s5); mbBus2.Hreg(0x0309, s6); mbBus2.Ireg(0x0309, s6);
mbBus2.Hreg(0x030A, s7); mbBus2.Ireg(0x030A, s7);
mbBus2.Hreg(0x030B, 0x0050); mbBus2.Ireg(0x030B, 0x0050);
mbBus2.Hreg(0x030C, 0xFEA7); mbBus2.Ireg(0x030C, 0xFEA7);
mbBus2.Hreg(0x030D, 0x0210); mbBus2.Ireg(0x030D, 0x0210);
mbBus2.Hreg(0x030E, 0xFFD9); mbBus2.Ireg(0x030E, 0xFFD9);
mbBus2.Hreg(0x030F, 0x0001); mbBus2.Ireg(0x030F, 0x0001);
mbBus2.Hreg(0x1103, 0x0001); mbBus2.Ireg(0x1103, 0x0001);
mbBus2.Hreg(0x5000, s1); mbBus2.Ireg(0x5000, s1); mbBus2.Hreg(0x5001, s2); mbBus2.Ireg(0x5001, s2);
mbBus2.Hreg(0x5002, s3); mbBus2.Ireg(0x5002, s3); mbBus2.Hreg(0x5003, s4); mbBus2.Ireg(0x5003, s4);
}
void refreshLiveProxyData() {
int32_t line_V12 = getInt32(extLiveBlock, 6); // L1-L2
int32_t line_V23 = getInt32(extLiveBlock, 8); // L2-L3
int32_t line_V31 = getInt32(extLiveBlock, 10); // L3-L1
// 1. Voltages Mapping (Phase L2 remains Virtual Neutral)
injectInt32IntoBus2(0x0000, line_V12); // Voltage L1-N = Line L1-L2
injectInt32IntoBus2(0x0002, 0); // Voltage L2-N = Forced 0.0V
injectInt32IntoBus2(0x0004, line_V23); // Voltage L3-N = Line L3-L2
injectInt32IntoBus2(0x0006, line_V12);
injectInt32IntoBus2(0x0008, line_V23);
injectInt32IntoBus2(0x000A, line_V31);
mbBus2.Hreg(0x000B, 1760); mbBus2.Ireg(0x000B, 1760);
// 2. Real Currents Pass-Through
injectInt32IntoBus2(0x000C, getInt32(extLiveBlock, 12));
injectInt32IntoBus2(0x000E, getInt32(extLiveBlock, 14));
injectInt32IntoBus2(0x0010, getInt32(extLiveBlock, 16));
// 3. HARDENED BALANCING MATHEMATICS (Phase 2 Power Allocation)
int32_t real_P1 = getInt32(extLiveBlock, 18);
int32_t real_P2 = getInt32(extLiveBlock, 20);
int32_t real_P3 = getInt32(extLiveBlock, 22);
int32_t manipulated_P1 = real_P1 + (real_P2 / 2);
int32_t manipulated_P3 = real_P3 + (real_P2 / 2);
injectInt32IntoBus2(0x0012, manipulated_P1); // Virtualized L1 Power
injectInt32IntoBus2(0x0014, 0); // Forced L2 Power to 0W
injectInt32IntoBus2(0x0016, manipulated_P3); // Virtualized L3 Power
// 4. TOTAL ACTIVE POWER RECONCILIATION
int32_t trueTotalSystemPower = real_P1 + real_P2 + real_P3;
injectInt32IntoBus2(0x0028, trueTotalSystemPower);
// 5. Secondary Grid Context
mbBus2.Hreg(0x002E, extPhasePF[0]); mbBus2.Ireg(0x002E, extPhasePF[0]); // L1 PF
mbBus2.Hreg(0x002F, extPhasePF[1]); mbBus2.Ireg(0x002F, extPhasePF[1]); // L2 PF
mbBus2.Hreg(0x0030, extPhasePF[2]); mbBus2.Ireg(0x0030, extPhasePF[2]); // L3 PF
mbBus2.Hreg(0x0032, extFreqSeq[0]); mbBus2.Ireg(0x0032, extFreqSeq[0]); // Sequence
mbBus2.Hreg(0x0033, extFreqSeq[1]); mbBus2.Ireg(0x0033, extFreqSeq[1]); // Grid Frequency
injectInt32IntoBus2(0x0034, getInt32(extEnergy, 0));
}
void setup() {
Serial.begin(115200);
while (!Serial);
// Initialize both lines at their specific target rates
SerialMeter.begin(115200, SERIAL_8N1, METER_RX, METER_TX); // Bus 1 Turbo Rate
SerialGX.begin(9600, SERIAL_8N1, GX_RX, GX_TX); // Bus 2 Victron Rate
mbBus1.begin(&SerialMeter, METER_DE_RE);
mbBus1.master();
mbBus2.begin(&SerialGX, -1);
mbBus2.slave(VICTRON_SLAVE_ID);
preLoadStaticHandshakeConstants();
Serial.println("[SYSTEM ONLINE] Ultra-Speed Delta Balancing Proxy Engaged.");
}
void loop() {
mbBus1.task();
mbBus2.task();
// TURBO FAST LOOP (Every 50ms)
if (bus1JobDone && (millis() - lastFastPoll > 50)) {
lastFastPoll = millis();
bus1JobDone = false;
mbBus1.readIreg(EM540_SLAVE_ID, 0x0000, extLiveBlock, 24, cbMasterFinished);
refreshLiveProxyData();
}
// BACKGROUND CONTEXT LOOP (Every 2000ms) - UPDATED FOR 5 MODBUS CYCLES
if (bus1JobDone && (millis() - lastSlowPoll > 2000)) {
lastSlowPoll = millis();
bus1JobDone = false;
switch (slowState) {
case 0: mbBus1.readIreg(EM540_SLAVE_ID, 0x002E, extPhasePF, 3, cbMasterFinished); break;
case 1: mbBus1.readIreg(EM540_SLAVE_ID, 0x0032, extFreqSeq, 2, cbMasterFinished); break;
case 2: mbBus1.readIreg(EM540_SLAVE_ID, 0x0034, extEnergy, 2, cbMasterFinished); break; // kWh (+) TOT
case 3: mbBus1.readIreg(EM540_SLAVE_ID, 0x0040, extPhaseEnergy, 6, cbMasterFinished); break; // L1, L2, L3 kWh (+)
case 4: mbBus1.readIreg(EM540_SLAVE_ID, 0x004E, extNegEnergy, 2, cbMasterFinished); break; // kWh (-) TOT
}
slowState = (slowState + 1) % 5;
}
}
Use code with caution. Software is AI generated.
Do not forget USB to 485 cable. This one works directly Multiplus - EM540, but does not manipulate the values. It can be used for fast start of the system.
USB Cable RS485 Compatible for Gerbox GX EM540 Grid Meter EM112 Victron ET112 Wired Connection FT232RNL RS485 Serial Converter Cable Adapter
Hello! A lot of work! But what ever you do, the cerbo will always translate it to a 3PN4W net. Depending to the hardware connectios you will get a 3x135v net or a 230v-0v-230v net. As i mentioned before i use the Elgris P1 meter, this meter gives exactly the same and correct power of the the Fluvius meter, in fact with the correct power (and current) you can skip the (wrong) voltage with node-red. You only have to use the total power or individual current with your own correct voltage. For the moment my PV and my load is so good as completly on L1 and L3 (but you can use L2 aswell if you want to) and my zero feed works very fine. So i recommend to use the Elgris P1 in a delta net 3x230v. i’ve tried all the energymeters (ET320, the new VM3P75CT, EM540,EM24,…) and always with the same issue: The cerbo always translate it to a 3PN4W net and so you can not change the voltage in the cerbo to 3x230v. So, you have to use a workaround with nodered or let Fluvius change your net to 3PN4W.
What do you mean by this? You mean internally, or the reset bit at any start of the communication?
If you refer to the reset bit, with ESP32 in between, that is also solved. However, it does not change anything, if the EM540 is in 3Pn or 3P. Multiplus-2 GX works same. At least for me.
To me, solved. Wires. Now indication correct. Even so, I do not believe Multiplus does care about it.
whatever you do (hardware/software) the cerbo will always handle the voltage of a netmeter (ET320,…) as 3x135v or 2x230v+1x0v within an 3p-net (3Pole3Wires) as it always handle a 3x400+N-net (3PN4W-net) by standard. Only TOTAL Power can be adjust with node-red or by use of an Elgris P1-meter. Hope now it’s clear?
As far as i know it’s a calculation by the system. You cannot refer to it. If there is a formule for it, i am very interest in it.
You could recalculate the measurements to suit a 3x400V/230V grid. Voltages are easy, but currents and power is a bit more complicated. You could do this in nodered, then use a virtual gridmeter with the corrected figures instead
To me looks kind of bug in the system. I read official meter separately via P1 port and total power reported by EM540 and are very close (to not say same. Not bad.). As Victron does see PV inverter or something else as house consumtion, it is not a big deal for me. The system is stabil and works nice. It is just a matter of Victron web representation. In real is fine.
I have seen many comments with “do not use Victron in Belgian 3x230 system. Will not work.” I can’t see problems. In my case it does work from May and it is doing as expected. Small grid consumtion of 0.1kwh per day, time to time. No problem. I can’t see the reason not to use Victron in 3x230V system.
Mart was when I’ve started. With some struggling as I was doing almost all on my own. (With some stupid actions of course…)
But June only 10 kwh from grid. Not bad at all.
(10 because the wife believes she now can start all consummers in same time… My MP-2 GX 3kw does what it can… 
)
So, all in all, happy days.
Next challenge: To make my house conform with all these expencive requirements. Ex: 300mA Type B and special distribution. Extra electric panel… etc… But, law is law if you want to be covered by insurance. We can’t comment that…
In same time, making reservation for upcoming EV charger. We like it or not, we will all be hit by it one day… (EV charger on 3x230 will only be able to take 7kw. But that is a different storry. Maybe by then 3x380+N will come… 
not …)
If I compare with 2025 it is almost 90% reduction of grid consumption.
Hello Viorel_C,
Indeed, if you make a virtual meter it is possible to make a “work around” and recalculate the total power, but anyway the P1 port do that for you, so it’s a matter of what you prefer as long as you know that the voltage itsn’t correct. In the last months (>may) in Belgium you should be able to have a nearly zero import (<0.2KWh/day) unless you have a load at acIN that you do not take in form in your calculation. In fact, unless you have certificates for your pv (like i do), you should be able to go off grid. But all by all, good results 
. If you take a ev-charger from victron, you can managed it very easy and depending on your total import current en cap.power you can regulate the power as you wish. What i do not understand is this:“As Victron does see PV inverter or something else as house consumption, it is not a big deal for me”. In Belgium you have to connect your PV-converter to AC-out of your 3xMPII (unless you use MPTT), otherwise your total (possible) export power is Power pv + Power MPII or max. power has to be <10KW. So at ACout it’s a sommation of essential power and pv-power. I use also an extra PV-meter (em24) so i can use this pv-power in my calculation in node red to do some regulation. Thx to share your experience.
Hello chrigu,
If i use the P1 meter as netmeter (=offical power consumption) and only use the total power, and the current of my own meters, i can do all the calculations i need in nodered, so all load at acout on the MPII’s is calculate correct by the MPII’s. Or is there something i’ve missed in this look of view?
3x230V grid without Neutral is not supported by Victron.
You may be able to use multiple MPs set up in threephase config. It might work, it might not. A threephase VE.Bus system is always based on a grid with neutral. So setting the MPs up for that but then connecting them in a delta config might just end in the units releasing the magic smoke. Even if you disable the internal N-PE relay.
In theory it should be possible to use the ACout, even in a threephase delta config, but im not sure. I feel like theres got to be an underlying reason this config is not supported by Victron, so it cant be as easy as connecting one MPs neutral to anothers phase to create the delta.
While ive got three 48/800 MPs to test various multiphase things with, im not sure if im interested enough to try this 
So far the above systems used a single MP2 on one of the phases, using only ACin. Which is also shoehorned in, but seems to work at least.
In a threephase system, you could use the total power as the only source of information, so the three MPs would simply split that by three, each producing/charging with the same power.
