Recopilación y visualización de datos Modbus TCP

Última actualización: 2026-10-16

Introducción

Modbus es un protocolo de comunicación habitual en la automatización industrial para leer datos de PLC, medidores y otros dispositivos industriales. La integración Modbus de Home Assistant convierte valores de registros en entidades de sensores y muestra su estado actual e historial en una interfaz web.

Este tutorial utiliza reComputer RK3576 y Home Assistant Container para leer temperatura y humedad mediante Modbus TCP y crear un panel de monitorización. Para facilitar la reproducción, se ejecuta un simulador Python Modbus TCP localmente en RK3576, sin necesidad de un PLC ni sensores adicionales.

Arquitectura

text

Python Modbus TCP simulator
     127.0.0.1:1502
            ↓
     reComputer RK3576
            ↓
 Home Assistant Container
            ↓
 Live temperature/humidity / history graphs

Preparación

Hardware

Un reComputer RK3576 con Linux ARM64.
Un ordenador Windows, macOS o Linux con acceso a RK3576 mediante SSH y un navegador.
Una red local con acceso a RK3576.

Este ejemplo utiliza Modbus TCP y no depende de la interfaz RS485 de RK3576.

Software

Elemento	Entorno del tutorial
Sistema operativo de RK3576	Armbian / Debian 12 Bookworm (ARM64)
Python	Python 3.11
Home Assistant	Home Assistant Container, desplegado con Docker
Simulador Modbus	`127.0.0.1:1502`
Interfaz web de Home Assistant	Puerto `8123`

Primero completa el despliegue con Docker y la configuración inicial de Instalar Home Assistant en reComputer RK3576. Comprueba el entorno:

bash

python3 --version
sudo docker ps --filter name=homeassistant
sudo docker inspect homeassistant --format '{{.HostConfig.NetworkMode}}'

El modo de red debe ser host. Así el contenedor puede acceder al simulador en 127.0.0.1:1502 del host RK3576.

Crear una fuente de datos Modbus TCP

Paso 1: Escribir el simulador Python

Conéctate a RK3576 mediante SSH. Copia el comando completo en el terminal para crear ~/modbus_demo.py en el directorio personal del usuario actual:

bash

cat > ~/modbus_demo.py <<'PY'
import math
import socketserver
import struct
import time


class ModbusHandler(socketserver.BaseRequestHandler):
    def read_exact(self, size):
        data = b""
        while len(data) < size:
            chunk = self.request.recv(size - len(data))
            if not chunk:
                return None
            data += chunk
        return data

    def handle(self):
        try:
            while True:
                header = self.read_exact(7)
                if not header:
                    break

                tid, pid, length, unit = struct.unpack(">HHHB", header)
                if pid != 0 or not 2 <= length <= 254:
                    break

                request = self.read_exact(length - 1)
                if not request:
                    break

                function = request[0]
                if function == 3 and len(request) == 5:
                    address, count = struct.unpack(">HH", request[1:])

                    if count < 1 or count > 2 or address + count > 2:
                        response = bytes([0x83, 2])
                    else:
                        temperature = round(
                            (25 + 2 * math.sin(time.monotonic() / 20)) * 10
                        )
                        humidity = round(
                            (60 + 10 * math.sin(time.monotonic() / 30)) * 10
                        )
                        registers = [temperature, humidity]
                        response = bytes([3, count * 2]) + b"".join(
                            struct.pack(">H", value)
                            for value in registers[address:address + count]
                        )
                else:
                    response = bytes([function | 0x80, 1])

                reply = struct.pack(">HHHB", tid, 0, len(response) + 1, unit) + response
                self.request.sendall(reply)
        except (OSError, ConnectionError):
            pass


class ModbusServer(socketserver.ThreadingTCPServer):
    allow_reuse_address = True
    daemon_threads = True


with ModbusServer(("127.0.0.1", 1502), ModbusHandler) as server:
    print("Modbus TCP server running at 127.0.0.1:1502", flush=True)
    server.serve_forever()
PY

El simulador admite el código de función 03 para leer registros de retención:

Dirección (desde 0)	Valor	Valor bruto	Valor mostrado
`0`	Temperatura	Aproximadamente 230–270	Aproximadamente 23–27 °C
`1`	Humedad	Aproximadamente 500–700	Aproximadamente 50–70%

Home Assistant utiliza scale: 0.1 para convertir los valores brutos en grados Celsius y porcentajes. Los valores cambian con el tiempo para demostrar la monitorización en directo.

Paso 2: Ejecutar el simulador

Inicia el simulador:

bash

nohup python3 ~/modbus_demo.py > ~/modbus_demo.log 2>&1 &

Confirma que está escuchando:

bash

ss -lntp | grep ':1502'
cat ~/modbus_demo.log

Deberías ver la dirección de escucha 127.0.0.1:1502 y este mensaje:

text

Modbus TCP server running at 127.0.0.1:1502

La demostración se ejecuta en segundo plano con nohup. Tras reiniciar RK3576, ejecuta de nuevo el comando de inicio. Comprueba el puerto antes de iniciarla para evitar instancias duplicadas.

Configurar Modbus TCP en Home Assistant

Paso 3: Editar configuration.yaml

Como se utiliza Home Assistant Container, no necesitas la aplicación File Editor. Edita directamente mediante SSH el archivo de configuración montado en RK3576.

Haz una copia de seguridad de la configuración existente:

bash

sudo cp ~/homeassistant/config/configuration.yaml \
  ~/homeassistant/config/configuration.yaml.bak

Abre el archivo con permisos de administrador:

bash

sudo nano ~/homeassistant/config/configuration.yaml

Conserva la configuración existente, como default_config: y frontend:, y añade lo siguiente:

yaml

modbus:
  - name: rk3576_demo
    type: tcp
    host: 127.0.0.1
    port: 1502

    sensors:
      - name: RK3576 Room Temperature
        unique_id: rk3576_demo_temperature
        slave: 1
        address: 0
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: "°C"
        device_class: temperature
        state_class: measurement
        scan_interval: 5

      - name: RK3576 Room Humidity
        unique_id: rk3576_demo_humidity
        slave: 1
        address: 1
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: "%"
        device_class: humidity
        state_class: measurement
        scan_interval: 5

Los parámetros principales son:

Parámetro	Función
`type: tcp`	Utilizar Modbus TCP
`host: 127.0.0.1`	Dirección local del simulador
`port: 1502`	Puerto de escucha
`slave: 1`	ID de unidad Modbus
`address: 0 / 1`	Direcciones de los registros de temperatura / humedad
`input_type: holding`	Leer registros de retención
`scale: 0.1`	Escalar los valores brutos a los mostrados
`scan_interval: 5`	Consultar cada 5 segundos

Si configuration.yaml ya contiene una clave modbus: de nivel superior, incorpora el nuevo hub a la lista existente en vez de declarar modbus: otra vez.

Pulsa Ctrl + O y luego Enter para guardar. Pulsa Ctrl + X para salir de nano.

Paso 4: Comprobar la configuración y reiniciar el contenedor

Valida primero la configuración de Home Assistant:

bash

sudo docker exec homeassistant \
  python -m homeassistant --script check_config --config /config

Si la comprobación pasa, reinicia Home Assistant:

bash

sudo docker restart homeassistant

Abre esta dirección en el navegador del ordenador:

text

http://<RK3576_IP>:8123

Ver los sensores Modbus

Paso 5: Confirmar la lectura de datos

En la interfaz probada de Home Assistant, abre Settings → Tools → States y busca rk3576. Confirma que estos sensores existen y muestran valores numéricos:

RK3576 Room Temperature
RK3576 Room Humidity

También puedes añadir ambos sensores al resumen mediante Overview → Edit overview → Favorite entities → Add favorite.

Confirmar los sensores Modbus de temperatura y humedad de RK3576

Crear un panel de monitorización Modbus

Paso 6: Crear el panel

Abre Settings → Dashboards y selecciona Add dashboard en la esquina inferior derecha.

En Add new dashboard, introduce:

Campo	Valor
Title	`RK3576 Modbus Monitoring`
Icon	Opcionalmente, un icono de termómetro
URL	`rk3576-modbus`
Admin-only	Desactivado
Add to sidebar	Activado

Selecciona Create y abre el nuevo panel desde la barra lateral.

Crear el panel de monitorización Modbus de RK3576

Paso 7: Añadir indicadores de temperatura y humedad

En el editor del panel, selecciona + en New section y elige Add to dashboard → By card → Gauge.

Configura dos tarjetas Gauge:

Ajuste	Indicador de temperatura	Indicador de humedad
Entity	RK3576 Room Temperature	RK3576 Room Humidity
Minimum	`0`	`0`
Maximum	`50`	`100`

Selecciona Save en cada tarjeta.

Añadir indicadores de temperatura y humedad

Paso 8: Añadir un gráfico histórico

Selecciona de nuevo + en New section y elige By card → History graph.

En History graph card configuration:

Establece Title en RK3576 Modbus Sensor History.
Establece Hours to show en 1.
Elimina la entidad predeterminada Sun de Entities (required).
Selecciona Add entity y añade RK3576 Room Temperature.
Selecciona Add entity de nuevo y añade RK3576 Room Humidity.
Selecciona Save y después Done en el editor.

La temperatura y la humedad utilizan unidades distintas, por lo que Home Assistant puede mostrar gráficos separados. También puedes crear una tarjeta independiente para cada sensor.

Añadir un gráfico histórico de sensores Modbus

Resultados

El panel del registro de prueba proporcionado de RK3576 incluye indicadores de temperatura y humedad y un gráfico histórico de humedad que muestra sus cambios con el tiempo.

Monitorización Modbus TCP de temperatura y humedad con Home Assistant en reComputer RK3576

En esa prueba se verificó la siguiente cadena:

Simulador Python Modbus TCP → RK3576 → Home Assistant Container → Panel web.

Los valores de temperatura y humedad son simulados. Para conectar un PLC, contador inteligente o sensor Modbus TCP real, adapta host, port, slave, las direcciones de registros y los tipos de datos al dispositivo.

Resumen

Estos pasos permiten la recopilación de datos Modbus TCP, la visualización del estado en directo y del historial en reComputer RK3576. El ejemplo proporciona una base reproducible para automatización doméstica, monitorización IoT local y pasarelas industriales.

Referencias

Soporte técnico y discusión sobre productos

Para preguntas, visita Seeed Studio Forum.

AnteriorInstalar Home Assistant

SiguientePersonalizar la interfaz con HACS y Catppuccin