Chiller and Inverter Telemetry Synchronization with Modbus TCP and MQTT

The Challenge of Thermal Integration in Building Automation Systems

Managing the climate control of large buildings is a task that requires millimeter precision. A BMS system (Building Management System, which acts as the electronic brain of the building) needs to coordinate chillers, which are the large equipment responsible for cooling the water circulating through the central air conditioning. In practice, this means collecting hundreds of variables per second to ensure thermal comfort without wasting electricity.

However, legacy refrigeration infrastructure usually speaks only traditional industrial dialects, such as Modbus TCP (a communication protocol that sends data packets directly between machines over ordinary computer networks). On the other hand, modern cloud analytics platforms demand lightweight, modern protocols like MQTT (Message Queuing Telemetry Transport, a system that works like a message group where devices only send updates when something changes).

The major engineering hurdle lies in bridging these two worlds without dropping packets or overloading programmable logic controllers (PLCs), which are the robust mini-computers installed in machine rooms. When telemetry fails, operators lose visibility into energy performance, resulting in astronomical electric bills and risks of compressor failure.

Hybrid Architecture: Uniting Modbus TCP and MQTT in the Field

To solve this bottleneck, the best strategy is to design a hybrid network architecture. In this approach, Modbus TCP is maintained at the field layer, extracting data directly from the electronic boards of chillers and frequency inverters (devices that regulate the speed of electric motors to save energy). In practice, the inverter tells you exactly how much force the motor is exerting, while the chiller reports the inlet and outlet water temperatures.

Halfway between the machines and the cloud, we position an edge gateway (a compact, rugged computer installed right in the machine room). This gateway runs conversion software that translates Modbus requests into structured MQTT packets. This way, the local network does not suffer from bottlenecks, and external traffic consumes very little internet bandwidth, sending only what is strictly necessary.

One of the biggest trade-offs of this design choice is managing connection state. While Modbus TCP requires the system to actively ask 'what is the temperature right now?', MQTT allows the sensor to spontaneously announce 'the temperature changed to 7 degrees'. This paradigm shift requires the programmer to know how to handle message queues and lost packets if the internet drops temporarily.

Practical Implementation with Asynchronous Collection

Below we present an example Python script running on the edge gateway, responsible for reading frequency inverter registers via Modbus TCP and publishing the consolidated values to an MQTT broker. The code uses standard market libraries to ensure long-term operational stability.

import time
import json
from pymodbus.client import ModbusTcpClient
import paho.mqtt.client as mqtt

# Field and cloud connection configuration
MODBUS_IP = '192.168.1.50'
MODBUS_PORT = 502
MQTT_BROKER = 'broker.local'
TOPIC = 'building/chiller/inverter_01'

client_modbus = ModbusTcpClient(MODBUS_IP, port=MODBUS_PORT)
client_mqtt = mqtt.Client()

client_mqtt.connect(MQTT_BROKER, 1883, 60)
client_modbus.connect()

try:
    while True:
        # Reading inverter frequency and current registers
        result = client_modbus.read_holding_registers(address=30001, count=2, slave=1)
        if not result.isError():
            frequency = result.registers[0] / 10.0
            current = result.registers[1] / 100.0
            
            payload = json.dumps({
                'frequency_hz': frequency,
                'current_a': current,
                'timestamp': time.time()
            })
            
            client_mqtt.publish(TOPIC, payload)
        time.sleep(5)
except KeyboardInterrupt:
    client_modbus.close()
    client_mqtt.disconnect()

This code snippet demonstrates operational simplicity when protocols are intelligently combined. Reading occurs every five seconds, avoiding unnecessary wear on the Modbus network and ensuring that the control panel receives consistent data.

Exception Handling and Edge Resilience

In industrial environments, power outages and electromagnetic interference are routine. Therefore, blindly trusting the network connection is a critical design flaw. In practice, the gateway software must implement robust mechanisms for automatic reconnection and local temporary storage if the MQTT broker becomes unreachable.

If the internet drops, chiller telemetry data cannot simply be discarded. They must be saved in a lightweight file-based local database, such as SQLite. As soon as connectivity is restored, the gateway flushes the accumulated messages in chronological order, preserving the complete history for future energy audits.

Furthermore, monitoring the gateway itself becomes vital. Observability tools should track RAM usage and processing of the mini-computer in the machine room, alerting the technical team before software crashes compromise the thermal comfort of the entire building.

Final Considerations on Energy Efficiency

Efficient synchronization between chillers and frequency inverters through hybrid protocols transforms commercial buildings into smart and highly economical structures. By combining the industrial robustness of Modbus TCP with the scalability of MQTT, engineers can extract maximum performance from equipment without compromising operational stability.

The secret to success lies in careful planning of the edge layer and rigorous handling of network failures. With reliable telemetry in hand, building managers stop fighting operational fires and start acting proactively, ensuring sustainability and real savings for the business.