# Constructor de Tramas Modbus

> Una página de jmrp.io, publicada como markdown. Índice: https://jmrp.io/llms.txt

Canonical: https://jmrp.io/es/tools/modbus-frame-builder/
Language: es
Alternate: https://jmrp.io/tools/modbus-frame-builder/index.md
Updated: 2026-09-03
License: https://jmrp.io/es/license/
Category: embedded
Tags: modbus, rtu, tcp, industrial, plc, embebido, serial

Construye y decodifica tramas Modbus RTU/TCP/ASCII con cálculo de CRC-16/LRC e interpretación de registros. Todo en el navegador.
Build-Date: 2026-09-06

Características:
- Construye tramas Modbus RTU, TCP y ASCII
- CRC-16, LRC y cabeceras MBAP automáticos
- Decodifica tramas hex y detecta excepciones
- Interpreta registros con orden de bytes seleccionable
- Funciona en el navegador, sin servidor

Preguntas que responde:

**¿Cuál es la diferencia entre las tramas Modbus RTU y Modbus TCP?**

Las tramas RTU son binarias y terminan con un CRC de 16 bits para líneas serie, mientras que las TCP anteponen una cabecera MBAP de 7 bytes (transaction ID, protocol ID, longitud, unit ID) y omiten el CRC porque TCP/IP se encarga del control de errores. Esta herramienta construye y decodifica ambas, además de Modbus ASCII con LRC.

**¿Cómo se calcula el CRC-16 de Modbus RTU?**

Usa el polinomio CRC-16 0xA001 (forma reflejada de 0x8005) calculado sobre todos los bytes excepto el propio CRC, y se añade primero el byte bajo y después el alto. La herramienta lo calcula y valida automáticamente al construir o decodificar una trama.

**¿Por qué mis valores de registro de 32 bits aparecen incorrectos al decodificar?**

Los registros Modbus son de 16 bits, por lo que los enteros y floats de 32 bits ocupan dos registros y los fabricantes no coinciden en el orden. Prueba a cambiar el orden de bytes entre Big-Endian, Little-Endian, Mid Big-Endian y Mid Little-Endian en el panel de interpretación de datos hasta que el valor coincida con tu dispositivo.

**¿Qué aspecto tiene una respuesta de excepción Modbus?**

El esclavo devuelve el function code en OR con 0x80 seguido de un código de excepción como 01 (Illegal Function) o 02 (Illegal Data Address). Pega la trama en el modo Decodificar trama y la herramienta detecta la excepción y nombra el error.

**¿Se envían mis datos Modbus a un servidor?**

No. Toda la construcción de tramas, decodificación, cálculo de CRC/LRC e interpretación de datos se realiza íntegramente en tu navegador; nada se transmite. El enlace compartible solo codifica los parámetros de la trama en los parámetros de la URL.


---

**Herramienta interactiva** — esta página contiene la aplicación en funcionamiento, no una descripción de ella.

## Acerca de esta herramienta

Construye tramas Modbus RTU, TCP y ASCII válidas para la comunicación con
dispositivos embebidos. La herramienta gestiona el cálculo de CRC-16 y LRC,
cabeceras MBAP, interpretación de valores de registros, generación de tramas
de respuesta y proporciona un desglose visual de cada byte de la trama con
segmentos codificados por colores.

### Características

- **Tres protocolos** — Modbus RTU (CRC-16), Modbus TCP (cabecera MBAP) y Modbus ASCII (LRC)
- **11 function codes** — Read Coils (01), Read Discrete Inputs (02), Read Holding Registers (03), Read Input Registers (04), Write Single Coil (05), Write Single Register (06), Read Exception Status (07), Diagnostics (08), Write Multiple Coils (0F), Write Multiple Registers (10), Read/Write Multiple Registers (17)
- **Decodificador de tramas** — pega tramas en hexadecimal para decodificar con autodetección de protocolo RTU/TCP, validación de CRC/LRC y detección de respuestas de excepción
- **Interpretación de datos** — decodifica datos de registros como Unsigned Int 16, Signed Int 16, Unsigned Int 32 o Float 32 con selección de orden de bytes (Big-Endian, Little-Endian, Mid Big-Endian, Mid Little-Endian)
- **Constructor de respuestas** — genera tramas de respuesta válidas para cualquier function code, incluyendo respuestas de excepción con todos los códigos de excepción estándar
- **Ayuda de formato de datos** — introduce valores decimales y conviértelos automáticamente a bytes hexadecimales, soportando uint16, int16, uint32 y float32
- **Cambio de formato de dirección** — alterna entre notación base 0, base 1 y notación Modicon (4xxxx, 3xxxx) con conversión automática
- **Presets comunes** — 8 ejemplos de tramas de carga rápida para pruebas instantáneas
- **Formatos de copia** — copia como hex con espacios, sin espacios, array de C o literal de bytes de Python
- **Bytes codificados por colores** — desglose visual con colores distintos para slave/unit, function code, datos, CRC/LRC, protocolo y segmentos de error
- **Enlace compartible** — URL compartible que codifica la configuración actual de la trama

### ¿Cómo uso esta herramienta?

#### Modo construcción

1. Selecciona el modo **Construir trama** (por defecto)
2. Elige el protocolo (RTU, TCP o ASCII)
3. Configura la dirección del esclavo, el function code, la dirección de inicio
  y la cantidad
4. Para funciones de escritura, introduce los datos en hexadecimal o usa la
  ayuda de formato de datos para introducir valores decimales/float
5. La trama se genera automáticamente con CRC-16 (RTU), cabecera MBAP (TCP) o
  LRC (ASCII)
6. Copia la trama en tu formato preferido usando los botones de copiar

#### Modo decodificación

1. Selecciona el modo **Decodificar trama**
2. Elige el protocolo o usa **Autodetectar**
3. Pega una trama en hexadecimal (p. ej., `01 03 04 00 0A 00 64 B2 62`)
4. Pulsa **Decodificar** o presiona Enter
5. Selecciona el formato de interpretación de datos (uint16, int16, float32,
  etc.) para ver los valores de los registros

#### Constructor de respuestas

1. Selecciona el modo **Constructor de respuesta**
2. Elige el function code para la respuesta
3. Introduce los datos de respuesta en bytes hexadecimales, o selecciona **Respuesta de excepción** para construir una trama de error

### Visión general del protocolo Modbus

Modbus es un protocolo de comunicación serie desarrollado por Modicon en 1979
para dispositivos industriales (PLCs, sensores, actuadores). Sigue una
arquitectura maestro/esclavo donde el maestro inicia las solicitudes y los
esclavos responden.

#### Estructuras de trama

| Protocolo | Estructura de trama | Verificación de error |
| --- | --- | --- |
| **RTU** | `[Slave] [FC] [Data...] [CRC Lo] [CRC Hi]` | CRC-16 |
| **TCP** | `[Transaction ID] [Protocol ID] [Length] [Unit ID] [FC] [Data...]` | TCP/IP |
| **ASCII** | `: [Slave] [FC] [Data...] [LRC] CR LF` | LRC |

### Referencia de function codes

| Código | Nombre | Tipo de dato | Acceso |
| --- | --- | --- | --- |
| `01` | Read Coils | Discrete Output (1 bit) | Lectura |
| `02` | Read Discrete Inputs | Discrete Input (1 bit) | Lectura |
| `03` | Read Holding Registers | Registro de 16 bits | Lectura |
| `04` | Read Input Registers | Registro de 16 bits | Lectura |
| `05` | Write Single Coil | Discrete Output (1 bit) | Escritura |
| `06` | Write Single Register | Registro de 16 bits | Escritura |
| `07` | Read Exception Status | 8 coils (diagnóstico) | Lectura |
| `08` | Diagnostics | Datos de sub-función | Lectura/Escritura |
| `0F` | Write Multiple Coils | Discrete Output (1 bit) | Escritura |
| `10` | Write Multiple Registers | Registro de 16 bits | Escritura |
| `17` | Read/Write Multiple Registers | Registro de 16 bits | Lectura/Escritura |

### Notación de direcciones Modicon

La documentación tradicional de Modbus usa rangos de direcciones Modicon para
identificar los tipos de datos:

| Rango | Tipo de dato | Function codes | Dirección de protocolo |
| --- | --- | --- | --- |
| `00001–09999` | Coils (salida discreta) | 01, 05, 0F | 0–9998 (0x0000–0x270E) |
| `10001–19999` | Discrete Inputs | 02 | 0–9998 (0x0000–0x270E) |
| `30001–39999` | Input Registers | 04 | 0–9998 (0x0000–0x270E) |
| `40001–49999` | Holding Registers | 03, 06, 10 | 0–9998 (0x0000–0x270E) |

### Códigos de excepción

Cuando un esclavo no puede procesar una solicitud, devuelve una **respuesta de excepción** con el function code en OR con `0x80` y un código de excepción:

| Código | Nombre | Descripción |
| --- | --- | --- |
| `01` | Illegal Function | Function code no soportado por el esclavo |
| `02` | Illegal Data Address | Dirección no disponible en el dispositivo esclavo |
| `03` | Illegal Data Value | Valor fuera de rango para el esclavo |
| `04` | Slave Device Failure | Error irrecuperable en el esclavo |
| `05` | Acknowledge | Solicitud aceptada pero el procesamiento requiere tiempo |
| `06` | Slave Device Busy | El esclavo está ocupado procesando otra solicitud |
| `08` | Memory Parity Error | Falló la verificación de paridad del área de archivo extendida |
| `0A` | Gateway Path Unavailable | Gateway mal configurado o no disponible |
| `0B` | Gateway Target No Response | El dispositivo de destino no respondió al gateway |

### Orden de bytes (endianness)

Los registros Modbus son de 16 bits, pero muchos dispositivos almacenan
valores de 32 bits (enteros, floats) en dos registros. El orden de bytes varía
según el fabricante:

| Nombre | Orden | Ejemplo (Float 123.456) |
| --- | --- | --- |
| **Big-Endian (AB CD)** | El más común, estándar Modbus | `42 F6 E9 79` |
| **Little-Endian (CD AB)** | Palabras intercambiadas | `E9 79 42 F6` |
| **Mid Big-Endian (BA DC)** | Bytes intercambiados | `F6 42 79 E9` |
| **Mid Little-Endian (DC BA)** | Completamente invertido | `79 E9 F6 42` |

### ¿Se envían mis datos Modbus a un servidor?

Toda la construcción de tramas, decodificación, cálculo de CRC/LRC e
interpretación de datos se realiza íntegramente en tu navegador. Ningún dato
Modbus se transmite a ningún servidor. El enlace compartible solo codifica los
parámetros de la trama en los parámetros de la URL.

### Referencia de comandos Linux

Herramientas comunes para probar la comunicación Modbus desde la línea de
comandos:

#### Leer Holding Registers con mbpoll

```bash
mbpoll -a 1 -r 0 -c 10 -t 4 /dev/ttyUSB0
```

**Salida de lectura mbpoll**

```text
mbpoll 1.5 - FieldTalk(tm) Modbus(R) Master Simulator
Protocol configuration: Modbus RTU
Slave configuration: address = [1]
-- Polling slave 1...
[0]: 100
[1]: 200
[2]: 0
[3]: 1500
[4]: 0
```

#### Leer registros vía TCP con modbus-cli

```bash
modbus read 192.168.1.100 %MW0 10
```

**Salida de modbus-cli**

```text
%MW0 = 100
%MW1 = 200
%MW2 = 0
%MW3 = 1500
```

#### Leer registros con pymodbus

```bash
python3 -c 'from pymodbus.client import ModbusTcpClient as C; c=C("192.168.1.100"); c.connect(); print(c.read_holding_registers(0,10,slave=1).registers)'
```

**Salida de pymodbus**

```text
[100, 200, 0, 1500, 0, 0, 0, 0, 0, 0]
```

#### Escribir un registro con mbpoll

```bash
mbpoll -a 1 -r 0 -t 4 /dev/ttyUSB0 -- 100
```

**Salida — Confirmación de escritura**

```text
mbpoll 1.5 - FieldTalk(tm) Modbus(R) Master Simulator
Written 1 reference(s).
```

#### Escanear dispositivos Modbus

```bash
for id in $(seq 1 247); do mbpoll -a $id -r 0 -c 1 -t 4 -1 /dev/ttyUSB0 2>/dev/null && echo "Device at $id"; done
```

**Salida — Resultados del escaneo**

```text
Device at 1
Device at 5
```

### ¿Cómo se calcula el CRC-16?

Modbus RTU usa CRC-16 con el polinomio `0xA001` (forma reflejada de `0x8005`). El CRC se calcula sobre todos los bytes de la trama excepto el propio CRC, y se añade en orden **little-endian** (byte bajo primero, byte alto segundo).

### ¿Cómo se calcula el LRC?

Modbus ASCII usa un Longitudinal Redundancy Check. El LRC es el **complemento a dos** de la suma de 8 bits de todos los bytes del mensaje (desde la dirección del esclavo hasta el último byte de datos). Se transmite como dos caracteres ASCII hexadecimales antes del CR LF final.