RS-485: un bus multipunto

01 · Un salto de topología

De RS-422 a RS-485

En el tema 23 vimos que un par diferencial rechaza el ruido de modo común, que RS-422 limita cada par a un solo transmisor (con hasta 10 receptores) y que, para que varios esclavos respondieran, habría que darle a cada uno su propio par de retorno. RS-485 (TIA/EIA-485) mantiene todo lo bueno de la señal diferencial (niveles, umbral de ±200 mV, par trenzado, hasta 1200 m y 10 Mbit/s) y agrega la pieza que faltaba: los transmisores pueden apagarse (pasar a alta impedancia), de modo que muchos de ellos comparten el mismo par, y cada uno habla solo cuando le toca.

Las consecuencias de ese cambio ocupan este tema:

• Con un solo par, la comunicación es half duplex: en un instante dado, o se transmite o se recibe. Alguien tiene que decidir cuándo, y el hardware necesita una señal de control de dirección.
• Como cualquier nodo puede estar hablando, el par queda a veces sin nadie que lo maneje: hay que decidir en qué estado queda (polarización).
• La línea tiene que verse igual desde cualquier punto: un único cable troncal, con terminadores en los dos extremos y derivaciones muy cortas.
• El protocolo de arriba tiene que impedir que dos nodos hablen a la vez. RS-485 no lo hace: define solo la capa eléctrica. Modbus RTU (tema 25) resuelve esto con un maestro que pregunta y un esclavo que responde.

02 · Compartir el par

Un par de hilos para muchos

La topología RS-485 típica es un bus lineal: un par trenzado que recorre toda la instalación, con los nodos conectados a lo largo (en la figura, un maestro y tres esclavos). Todos los dispositivos se conectan en paralelo a las mismas dos líneas. Sus características principales:

Dos números merecen explicación:

• La carga unitaria. Cada receptor de un nodo se comporta como una resistencia de entrada de unos 12 kΩ, que es 1 carga unitaria (1 UL). El estándar permite 32 UL en el bus. Los transceptores modernos tienen mayor impedancia de entrada: ½ UL (24 kΩ), ¼ UL (48 kΩ, como el MAX487, con hasta 128 nodos) o ⅛ UL (96 kΩ, como los SN65HVD72, hasta 256 nodos). La cuenta es sencilla: nodos máximos = 32 / UL de cada transceptor. Los terminadores y las resistencias de polarización también son carga para el driver.
• El rango de modo común ampliado (−7 V a +12 V), mayor que el de RS-422 (±7 V), pensado para tolerar las diferencias de masa entre nodos distantes. Aun así, es un rango finito: más allá, el receptor ya no garantiza la lectura.

La variante de cuatro hilos (dos pares) permite full duplex, como RS-422, pero con los mismos drivers apagables; se usa en esquemas maestro–esclavo donde el maestro nunca comparte el par de transmisión con los demás. La mayoría de las instalaciones usan la de dos hilos, más barata, y es la que desarrolla el resto del tema.

03 · El chip

El transceptor half duplex

Un transceptor RS-485 half duplex como el MAX485 contiene un driver y un receptor conectados a los mismos dos pines de línea (A y B). Tiene cuatro pines de lógica:

Lo habitual es unir DE y RE y manejarlos con un solo pin del microcontrolador: nivel alto = transmitir (driver activo, receptor apagado), nivel bajo = escuchar (driver apagado, receptor activo). Así el nodo está siempre en uno de los dos estados y no se escucha a sí mismo (sin eco). Cuando el nodo no está transmitiendo, DE está en bajo y el driver no carga el bus: eso es lo que permite que los demás transmitan.

Dos advertencias de uso práctico. Un MAX485 alimentado a 5 V no se conecta directamente a un microcontrolador de 3,3 V: su salida RO es de 0/5 V y llega al pin RX (las mismas consideraciones del tema 22). Se usa un transceptor de 3,3 V (MAX3485), o un divisor en RO. Y la salida del microcontrolador a DI y el pin que maneja DE/RE sí son compatibles (entradas con umbral de 2 V). Además, muchos módulos baratos «TTL a RS-485» traen el transceptor, las resistencias y a veces un circuito de dirección automática; conviene mirar el esquema.

04 · Reglas de convivencia

Uno habla, los demás escuchan

Si dos drivers activos mandan niveles contrarios sobre el mismo par, hay una contención: dos salidas luchan entre sí. Los transceptores RS-485 aguantan esa situación sin romperse (tienen limitación de corriente y apagado térmico), pero los datos se pierden y la línea queda con niveles que no son ninguno de los dos. El bus tiene tres estados posibles:

RS-485 no tiene ningún mecanismo que impida la contención: es responsabilidad del protocolo de arriba. Las soluciones usuales:

• Maestro–esclavo: un único maestro inicia toda conversación y cada esclavo responde solo cuando se le pregunta, identificado por una dirección. Es el modelo de Modbus RTU (tema 25) y de la mayoría de las redes industriales. La contención se evita por construcción.
• Paso de testigo (token passing): un mensaje especial circula entre los nodos y solo quien lo tiene puede hablar (Profibus, BACnet MS/TP).
• Escucha antes de hablar con esperas aleatorias, al estilo CSMA: más complejo y poco frecuente en RS-485.

Además, entre el final de un mensaje y el comienzo del siguiente que puede venir de otro nodo hace falta un pequeño tiempo de vuelta (turnaround): el que transmitía debe soltar el bus antes de que el otro lo ocupe, y el que va a responder debe darle tiempo al otro de cambiar a recepción. Con Modbus RTU son 3,5 tiempos de carácter de silencio.

05 · El problema de la sincronización

Dirección de transmisión: DE y RE

La UART del microcontrolador no sabe nada de RS-485. Entonces hay que levantar DE antes de transmitir y bajarlo después, y el momento de bajarlo importa. Una secuencia correcta es:

1. Levantar DE/RE (driver activo, receptor apagado).
2. Esperar el tiempo de habilitación del driver (del orden de cientos de nanosegundos; en la práctica, unas decenas de microsegundos de margen).
3. Escribir los bytes a la UART. En Arduino, Serial.write devuelve en cuanto copia los bytes a un buffer: la trama todavía no salió.
4. Esperar a que salga el último bit, incluido el de parada. En Arduino y ESP32, Serial.flush() bloquea hasta que la transmisión termina.
5. Bajar DE/RE (driver en alta impedancia, receptor activo) de inmediato.

Los dos errores típicos son simétricos:

• Liberar DE demasiado pronto (por ejemplo, justo después de write, sin flush): el driver se apaga con la trama todavía en el buffer. Se pierden los últimos bytes, o todos. El síntoma: el esclavo recibe la trama truncada o ni la ve.
• Liberar DE demasiado tarde (un delay generoso): el driver sigue activo cuando el esclavo empieza a contestar. Se pisan el final del mensaje y el comienzo de la respuesta. El síntoma: la respuesta llega sin su primer byte, o el maestro no la entiende.

Otras formas de resolver la dirección, que sacan este problema del programa:

• Hardware de dirección automática. Algunos transceptores (por ejemplo el MAX13487E) y muchos módulos económicos derivan DE de la propia señal TX con un circuito simple, y no necesitan pin de control. Funcionan bien a velocidades bajas y medias y pueden fallar a velocidades altas o con tramas pegadas.
• Modo RS-485 de la UART. Algunos microcontroladores generan el DE automáticamente desde la propia UART, con un pin RTS que se activa durante la transmisión. El ESP32 lo tiene (UART_MODE_RS485_HALF_DUPLEX), igual que varios STM32.
• Adaptadores USB-RS485. Los de calidad manejan la dirección solos; otros usan la línea RTS del puerto COM virtual y el controlador (Windows tiene opciones de «RS-485 por RTS»).

El eco es el último detalle. Si RE queda siempre en bajo (receptor siempre activo), el nodo recibe lo que él mismo transmite: la UART ve su propia trama de vuelta. A veces se aprovecha (para verificar que se transmitió bien), pero normalmente se descarta o se evita uniendo DE y RE.

06 · Cómo se arma la red

Topología y terminación

Las reglas de topología son las mismas del tema 23 para líneas de transmisión, ahora aplicadas a un bus con muchos puntos de conexión:

• Un cable troncal único, en daisy chain: de un nodo al siguiente, sin ramas largas, sin estrellas, sin lazos cerrados. Cada rama es una línea de transmisión extra que produce rebotes.
• Derivaciones (stubs) lo más cortas posible: el cable que va del troncal al transceptor debe tardar mucho menos que el tiempo de subida. Una regla práctica: que la ida y vuelta de la derivación sea menos de un sexto del tiempo de subida, es decir, longitud en metros < t_r / 60 con t_r en nanosegundos. Con flancos de 10 ns son unos 17 cm; con 40 ns, unos 70 cm; con flancos de 1 µs de un driver de pendiente limitada, unos 16 m.
• Terminadores de 120 Ω en los dos extremos físicos del bus, entre A y B, y en ningún otro lugar. Con dos terminadores la carga que ve un driver es de 60 Ω; con más, el driver se sobrecarga.
• Los extremos son los extremos físicos, no el maestro ni el primer nodo de una lista: si el maestro está en el medio de la línea, los terminadores van igual en las dos puntas del cable.

Como en el tema 23, un bus corto o lento perdona casi todo. Una instalación de 20 m a 9600 baudios anda con o sin terminadores; una de 600 m a 115 200 baudios o una de 100 m a 1 Mbit/s no. Pero poner los terminadores correctos desde el principio es gratis y evita fallas que aparecen cuando se agrega un nodo o se sube la velocidad.

07 · Cuando todos callan

Polarización del reposo

Entre mensajes todos los drivers están apagados y el par no lo maneja nadie. Los terminadores (60 Ω entre A y B) mantienen las dos líneas en el mismo potencial: V_AB ≈ 0 V, dentro del umbral de ±200 mV, donde la salida del receptor es indefinida. El ruido la hace oscilar, y la UART interpreta esa oscilación como una cadena de bytes falsos (o como bits de inicio que no existen). Un bus «silencioso» así produce basura.

La solución es la polarización (bias, fail-safe bias): dos resistencias, una hacia VCC en la línea no inversora y otra hacia masa en la línea inversora, en un único punto del bus (normalmente en el maestro o en un extremo). Con el bus en reposo forman un divisor con los terminadores y fijan una tensión diferencial positiva (la del reposo, que la UART interpreta como un 1):

donde R_t es la resistencia equivalente de los terminadores (60 Ω con dos) y R_b la de cada resistencia de polarización (si hay más de un punto de polarización, sus resistencias quedan en paralelo y R_b baja). Se necesita que V_AB supere los 200 mV del umbral con un margen para el ruido (se suele apuntar a unos 300 mV o más).

El compromiso es evidente: resistencias más chicas dan más margen pero cargan más al driver y consumen corriente permanente. Con 3,3 V, el mismo 470 Ω da solo 0,20 V (justo en el umbral) y hace falta bajar a 330 Ω (0,28 V). Y atención al número de puntos de polarización: si cada nodo trae sus propias resistencias de polarización (como hacen algunos módulos), quedan todas en paralelo y la polarización total puede ser exagerada (con dos puntos de 470 Ω a 5 V, V_AB sube a 0,57 V, pero el driver ve una carga menor). Lo recomendable es polarizar en un solo lugar y quitar las resistencias del resto.

La alternativa moderna son los receptores a prueba de fallas (fail-safe, como los de la familia SN65HVD72): sus umbrales están desplazados (−200 mV a −50 mV) de modo que V_AB = 0 se interpreta como un 1, y no hacen falta resistencias externas para el reposo. Sirven también cuando el cable está cortado o en cortocircuito. Aun así, muchas instalaciones polarizan por si hay nodos más viejos en el bus.

08 · Lo que no es el chip

Cable, masa y protección

Un bus RS-485 confiable se decide tanto en el cable como en los transceptores:

• Cable de par trenzado de 120 Ω (los cables específicos para RS-485/DMX, AWG 24 o similar), idealmente con malla. Un cable de red UTP (100 Ω) sirve en distancias medianas. Se cablea un solo par para A y B (los otros pares, si los hay, no se usan para otras señales).
• La referencia de masa. Los receptores toleran de −7 V a +12 V de modo común, pero las masas de nodos lejanos pueden diferir más, y los transceptores no aislados se conectan a tierra por caminos distintos. Un tercer hilo de referencia («común», «SC») con una resistencia de unos 100 Ω en cada extremo (para limitar la corriente de lazo) mantiene todos los nodos en el mismo potencial. En instalaciones con tierras distintas se usan transceptores aislados (con barrera galvánica y fuente aislada), que eliminan el problema de raíz.
• Blindaje conectado a tierra en un solo punto, como en el tema 23.
• Protección: los nodos de campo reciben descargas electrostáticas y picos inducidos (rayos cercanos, conmutación de cargas inductivas). Se usan transceptores con ESD de ±15 kV, diodos supresores de transitorios (TVS) bidireccionales de 12 V o más entre A, B y masa, y resistencias en serie. Un transceptor sin protección es lo primero que se rompe en un bus largo.
• Alimentación y desacople: un condensador de 100 nF junto a cada transceptor, y la alimentación bien filtrada. Los drivers conmutan corrientes de decenas de miliamperios.
• Longitud y velocidad: las mismas reglas del tema 23 (L ≈ 1,2 × 10⁸ / velocidad, con tope de 1200 m).

09 · Con el microcontrolador

Con el microcontrolador

Los dos programas siguientes forman un maestro y un esclavo mínimos sobre un bus RS-485 de dos hilos con un transceptor MAX3485 (3,3 V), DE y RE unidos al pin 4 y la UART 2 del ESP32 (RX = 16, TX = 17). La trama de ejemplo es de tres bytes: dirección del esclavo, comando y suma de verificación; el protocolo completo, con CRC, lo veremos con Modbus. El maestro implementa la secuencia correcta de dirección: levantar DE, escribir, esperar con flush, bajar DE y escuchar con un tiempo máximo.

// MAESTRO
const int PIN_RX = 16, PIN_TX = 17, PIN_DE = 4;           // DE y RE unidos
const unsigned long BAUD = 9600;

void rs485Enviar(const byte *datos, byte n) {
    digitalWrite(PIN_DE, HIGH);                           // driver activo, receptor apagado
    delayMicroseconds(50);                                // tiempo de habilitación del driver
    Serial2.write(datos, n);
    Serial2.flush();                                      // espera a que salga el último bit, incluido el de parada
    digitalWrite(PIN_DE, LOW);                            // vuelve a escuchar: el bus queda libre para la respuesta
}

byte rs485Recibir(byte *buf, byte maximo, unsigned long timeoutMs) {
    byte k = 0;
    unsigned long t0 = millis(), ultimo = t0;
    while (millis() - t0 < timeoutMs) {
        if (Serial2.available() && k < maximo) { buf[k++] = Serial2.read(); ultimo = millis(); }
        else if (k > 0 && millis() - ultimo > 5) break;      // 5 ms de silencio: fin de trama
    }
    return k;
}

byte suma(const byte *d, byte n) { byte s = 0; for (byte i = 0; i < n; i++) s += d[i]; return s; }

bool preguntar(byte direccion, byte comando, byte *respuesta) {
    byte pedido[3] = { direccion, comando, 0 };
    pedido[2] = suma(pedido, 2);
    rs485Enviar(pedido, 3);
    byte r[8];
    byte n = rs485Recibir(r, sizeof(r), 100);
    if (n == 0) { Serial.println("Sin respuesta (esclavo ausente, apagado o dirección equivocada)"); return false; }
    if (n < 3 || suma(r, n - 1) != r[n - 1]) { Serial.println("Respuesta corrupta"); return false; }
    if (r[0] != direccion) { Serial.println("Respondió otro nodo"); return false; }
    *respuesta = r[1];
    return true;
}

void setup() {
    Serial.begin(115200);
    Serial2.begin(BAUD, SERIAL_8N1, PIN_RX, PIN_TX);
    pinMode(PIN_DE, OUTPUT);
    digitalWrite(PIN_DE, LOW);                            // por defecto, escuchando
}

void loop() {
    byte valor;
    if (preguntar(0x05, 0x01, &valor)) { Serial.print("Esclavo 5, comando 1 -> "); Serial.println(valor); }
    delay(1000);
}

El esclavo escucha siempre; cuando llega una trama con su dirección y la suma correcta, espera un instante (el tiempo de vuelta) y contesta con la misma secuencia de dirección:

// ESCLAVO (dirección 5)
const int PIN_RX = 16, PIN_TX = 17, PIN_DE = 4;
const byte MI_DIRECCION = 0x05;

byte suma(const byte *d, byte n) { byte s = 0; for (byte i = 0; i < n; i++) s += d[i]; return s; }

void responder(byte comando, byte valor) {
    byte r[3] = { MI_DIRECCION, valor, 0 };
    r[2] = suma(r, 2);
    delay(2);                                             // tiempo de vuelta: deja que el maestro cambie a recepción
    digitalWrite(PIN_DE, HIGH);
    delayMicroseconds(50);
    Serial2.write(r, 3);
    Serial2.flush();
    digitalWrite(PIN_DE, LOW);
}

void setup() {
    Serial.begin(115200);
    Serial2.begin(9600, SERIAL_8N1, PIN_RX, PIN_TX);
    pinMode(PIN_DE, OUTPUT);
    digitalWrite(PIN_DE, LOW);
}

void loop() {
    static byte trama[3];
    static byte k = 0;
    static unsigned long ultimo = 0;
    if (k > 0 && millis() - ultimo > 5) k = 0;           // 5 ms de silencio: se descarta una trama a medias
    while (Serial2.available()) {
        trama[k++] = Serial2.read();
        ultimo = millis();
        if (k == 3) {
            k = 0;
            if (suma(trama, 2) == trama[2] && trama[0] == MI_DIRECCION) responder(trama[1], 42);   // valor de ejemplo
            // si la dirección no es la propia (o la suma no cierra), se ignora y no se contesta
        }
    }
}

Dos notas. La corrección de flush es lo que resuelve el problema de la sección 05; en un AVR, Serial.flush() también espera a que termine la transmisión. Y el protocolo de ejemplo es deliberadamente simple: no tiene CRC ni tolera tramas partidas ni direcciones de difusión. Para un ESP32 también se puede delegar la dirección a la UART con Serial2.setPins(PIN_RX, PIN_TX, -1, PIN_DE); Serial2.setMode(UART_MODE_RS485_HALF_DUPLEX); (la forma exacta depende de la versión del núcleo), y el programa se queda solo con write.

10 · Analogía con programación

El bus RS-485 en Python

Un bus RS-485 se puede modelar con unas pocas funciones: el estado del par según los drivers activos, la carga unitaria y el número de nodos, la tensión de reposo con polarización, el tiempo de la trama y los bytes que se pierden al liberar DE antes de tiempo, y la carga y los rebotes de distintas topologías. El programa siguiente reúne esos modelos.

import math

UL_OHM = 12000                                          # una carga unitaria = 12 kΩ


def paralelo(*r):
    return 1 / sum(1 / x for x in r)


def max_nodos(ul_por_nodo):
    return int(32 / ul_por_nodo)


def estado_bus(drivers, polarizado):
    """drivers: lista con 1, 0 o None (alta impedancia) por cada nodo."""
    activos = [d for d in drivers if d is not None]
    if not activos:
        return 1 if polarizado else "flotante (indefinido)"
    if len(set(activos)) > 1:
        return "conflicto (contención)"
    return activos[0]


def reposo_ab(vcc, rb, rt=60, puntos=1):
    return vcc * rt / (2 * (rb / puntos) + rt)


def bytes_perdidos(baud, n, retardo_ms):
    t_char = 10 / baud * 1000                            # ms por carácter (inicio + 8 datos + parada)
    terminados = min(n, int(retardo_ms / t_char + 1e-9))
    return n - terminados


def gamma(zl, z0=120):
    return (zl - z0) / (zl + z0)


print("Nodos máximos según la carga unitaria (carga total del bus con 32 UL y dos terminadores):")
for ul in (1, 0.5, 0.25, 0.125):
    n = max_nodos(ul)
    receptores = UL_OHM / (n * ul)
    print(f"  {ul:5} UL: {n:3} nodos; receptores {receptores:.0f} Ω en paralelo; con los terminadores, el driver ve {paralelo(60, receptores):.1f} Ω")

print()
print("Estado del par:")
for drivers, pol in (([None, None, None], True), ([None, None, None], False), ([1, None, None], False), ([1, 0, None], True)):
    print(f"  drivers {str(drivers):18} polarizado={pol!s:5} -> {estado_bus(drivers, pol)}")

print()
print("Tensión diferencial en reposo (dos terminadores):")
for rb in (330, 470, 680, 1000, 2200, 4700):
    print(f"  Rb = {rb:4} Ω a 5 V: {reposo_ab(5, rb):.3f} V; el driver ve {paralelo(60, 2 * rb):.1f} Ω")
print(f"  470 Ω a 3,3 V: {reposo_ab(3.3, 470):.3f} V; 330 Ω a 3,3 V: {reposo_ab(3.3, 330):.3f} V; dos puntos de 470 Ω a 5 V: {reposo_ab(5, 470, puntos=2):.3f} V")

print()
baud, n = 9600, 8
trama = n * 10 / baud * 1000
caracter = 10 / baud * 1000
print(f"Trama de {n} bytes a {baud} baudios: {trama:.2f} ms ({caracter:.2f} ms por carácter)")
for nombre, retardo in (("sin esperar", 0), ("1 ms fijo", 1), ("4 ms fijo", 4), ("exacto (trama)", trama), ("trama + 1 carácter", trama + caracter), ("18 ms fijo", 18)):
    extra = max(0, retardo - trama)
    print(f"  DE liberada {nombre:19}: {bytes_perdidos(baud, n, retardo)} byte(s) perdidos, DE de más {extra:.2f} ms")

print()
print("Topologías (impedancia de línea de 120 Ω):")
print(f"  bus terminado en los dos extremos: {paralelo(120, 120):.0f} Ω")
print(f"  un solo terminador: {120} Ω; tercer terminador en el medio o estrella de 3 ramas: {paralelo(120, 120, 120):.0f} Ω")
print(f"  coeficiente de reflexión en el nudo de una estrella de dos ramas: {gamma(paralelo(120, 120)):+.2f}")
print("  derivación máxima (t_r / 60 m):", {f"{tr} ns": f"{tr / 60:.2f} m" for tr in (10, 40, 1000)})

Resultado: con 1, ½, ¼ y ⅛ de carga unitaria el bus admite 32, 64, 128 y 256 nodos; en todos los casos con el máximo de nodos los receptores suman 375 Ω en paralelo y, con los dos terminadores, el driver ve 51,7 Ω. El par sin drivers activos vale 1 si está polarizado y «flotante (indefinido)» si no; con un driver activo vale el bit que transmite; con dos drivers que mandan niveles distintos hay conflicto. La tensión de reposo con 5 V y dos terminadores es de 0,417 V con 330 Ω, 0,300 V con 470 Ω, 0,211 V con 680 Ω, 0,146 V con 1 kΩ, 0,067 V con 2,2 kΩ y 0,032 V con 4,7 kΩ; con 3,3 V, 470 Ω da 0,198 V (por debajo del umbral) y 330 Ω, 0,275 V; con dos puntos de polarización de 470 Ω a 5 V, 0,566 V. Una trama de 8 bytes a 9600 baudios dura 8,33 ms (1,04 ms por carácter): liberar DE sin esperar o con 1 ms pierde los 8 bytes, con 4 ms pierde 5, exactamente al terminar la trama (8,33 ms) no pierde ninguno, y esperar de más (trama + 1 carácter, 18 ms) no pierde nada pero deja el driver activo 1,04 ms y 9,67 ms más de la cuenta, que pisarían una respuesta rápida. Un bus terminado en los dos extremos presenta 60 Ω, el tercer terminador baja la carga a 40 Ω, el nudo de una estrella de dos ramas tiene un coeficiente de reflexión de −0,33, y la derivación máxima orientativa es de 0,17 m con flancos de 10 ns, 0,67 m con 40 ns y 16,67 m con 1 µs.

Los modelos muestran dos cosas: cada decisión de diseño (terminadores, polarización, momento de liberar DE) tiene un número detrás, y casi todos esos números dependen de la velocidad y del tiempo de subida.

11 · Exploración interactiva

Laboratorio: nodos, polarización, dirección y topología

El laboratorio tiene cuatro herramientas. La primera cuenta cuántos nodos admite un bus según la carga unitaria y qué carga ve el driver. La segunda calcula la polarización del reposo. La tercera simula el momento de liberar DE frente a una trama y una respuesta rápida. La cuarta evalúa una topología y sus derivaciones.

En la herramienta 1, los receptores de todos los nodos están en paralelo (12 kΩ por carga unitaria) con los terminadores. En la 2, la polarización se pone en un punto o en varios (sus resistencias quedan en paralelo) y los terminadores están en las puntas. En la 3, el carácter dura 10 bits (inicio, 8 datos y parada). En la 4, la impedancia de línea es de 120 Ω y la velocidad de propagación, 5 ns/m.

Recorrido guiado

1. Con los valores iniciales (transceptores de 1 UL, 16 nodos, 2 terminadores): 16 cargas unitarias de las 32 permitidas, y el driver ve unos 56 Ω. «Dentro del límite».
2. Subí a 40 nodos con 1 UL: 40 UL superan las 32 permitidas («Demasiados nodos»). Cambiá a ¼ UL: ahora el límite es de 128 nodos y 40 nodos son 10 UL. Con ⅛ UL llegás a 256.
3. Probá con 3 terminadores: la carga baja a unos 38 Ω, por debajo de los 54 Ω de la especificación. Con 1 terminador, unos 103 Ω de carga y un extremo reflejando.
4. En la herramienta 2, con los valores iniciales (5 V, 470 Ω, un punto, dos terminadores, receptor estándar): 0,300 V en reposo, el receptor lee un 1 y el veredicto es «Polarizado». Pasá a 1 kΩ: 0,146 V, por debajo del umbral de 200 mV: «Indefinido». Con ninguna: 0 V.
5. Pasá a 3,3 V con 470 Ω: 0,198 V, apenas por debajo del umbral. Con 330 Ω: 0,275 V, que ya supera el umbral aunque con poco margen (el laboratorio lo marca como «Justo»). Con dos puntos de polarización de 470 Ω a 5 V: 0,566 V, pero el driver ve menos de 60 Ω.
6. Con «ninguna» y un receptor a prueba de fallas: V_AB = 0 V se lee como un 1 y no hacen falta resistencias. Es lo que hacen los transceptores modernos.
7. En la herramienta 3, con los valores iniciales (9600 baudios, 8 bytes, DE al terminar la trama con flush): la trama dura 8,33 ms, salen los 8 bytes, sin DE de más y sin conflicto. «Correcto».
8. Elegí «justo después de write»: salen 0 bytes de 8 (la trama quedó en el buffer cuando el driver se apagó). Con 1 ms, tampoco sale ninguno.
9. Elegí «trama + 10 ms»: todos los bytes salen pero DE queda activa 10 ms de más y el esclavo (a los 2 ms) empieza a contestar con el driver del maestro todavía activo: «Pisa la respuesta». Con trama + 1 carácter (1,04 ms de más) y un esclavo que contesta a los 2 ms, no hay problema; con uno que contesta a los 0,5 ms sí.
10. En la herramienta 4, el bus lineal terminado en los dos extremos da 60 Ω y es correcto. El de un solo extremo refleja en la punta abierta. Un tercer terminador en el medio y la estrella dan 40 Ω; la estrella además tiene un nudo que refleja (Γ ≈ −0,33).
11. Con «derivaciones» y 40 ns de subida: el máximo es de 0,67 m; con derivaciones de 0,3 m, bien; con 5 m, mal. Con 1 µs de subida (pendiente limitada) toleran 16,7 m.

12 · Un procedimiento

Diagnóstico de un bus RS-485

Un bus RS-485 que no anda se revisa de lo simple a lo complejo:

1. Con un solo maestro y un solo esclavo, cortos. Si ahí funciona, el problema está en la instalación (cable, terminadores, polarización, nodos). Si no, es de configuración o de dirección.
2. Mismo formato en todos (baudios, paridad, bits de parada) y direcciones distintas en cada esclavo.
3. Polaridad. Si hay silencio o datos negados, cruzar A y B en un nodo (tema 23). Es el error más común.
4. Mirar la dirección de transmisión. Con un osciloscopio o un analizador: DE debe subir antes de la trama y bajar justo después del último bit. Si baja antes, se pierden bytes; si baja tarde, se pisan las respuestas.
5. Medir en reposo. Con el bus callado, V_AB debe estar sobre 200 mV (y A más alta que B en la nomenclatura no inversora). Cerca de 0 V: falta polarización o está mal ubicada; un valor negativo: polaridad invertida.
6. Terminadores: con el equipo apagado, medir la resistencia entre A y B en cualquier punto: unos 60 Ω si hay dos terminadores (y ningún nodo conectado en medio con sus propios terminadores). Valores de 40 Ω, 30 Ω... señalan terminadores de más; 120 Ω, uno de menos; abierto, ninguno.
7. Agregar nodos de a uno. El que hace fallar al bus es un nodo defectuoso (driver que no se apaga, transceptor quemado, DE trabado en alto), una derivación larga o un exceso de carga.

13 · Comprensión

Confusiones frecuentes

14 · Práctica guiada

Predecí antes de comprobar

1. Cuántos nodos

Un bus industrial necesita 100 nodos. ¿Alcanza con transceptores de ¼ UL? ¿Y de ⅛ UL? ¿Cuántas cargas unitarias suman 100 nodos de ¼ UL?

2. Polarización a 3,3 V

Con 3,3 V, dos terminadores (60 Ω) y resistencias de polarización de 470 Ω, ¿cuánto vale V_AB en reposo? ¿Sirve? ¿Qué valor elegirías?

3. Liberar DE

Una trama de 10 bytes a 19 200 baudios. ¿Cuánto dura? Si el programa baja DE 2 ms después del write, ¿cuántos bytes alcanzan a salir?

4. Derivaciones

Un driver con flancos de 40 ns. ¿Cuánto puede medir como máximo la derivación que va del troncal a un nodo (regla t_r / 60)? ¿Y con un driver de 1 µs?

5. Medir con el equipo apagado

Con el bus apagado, un multímetro entre A y B marca 40 Ω. ¿Qué puede estar pasando? ¿Y si marca 120 Ω?

6. Todo el bus se cae

Cada vez que se enciende el nodo 7, ningún otro puede comunicarse. ¿Por qué razón puede ser, y cómo se evita?

7. Dos puntos de polarización

Cada uno de dos módulos trae polarización de 1 kΩ (arriba y abajo). Con 5 V y dos terminadores, ¿cuál es V_AB y qué carga ve el driver?

15 · Síntesis

Ideas para recordar

¿Listo para el siguiente tema?

Antes de avanzar, calculá V_AB en reposo con 5 V, dos terminadores y resistencias de polarización de 560 Ω; decidí en qué momento exacto bajarías DE después de transmitir 6 bytes a 9600 baudios y por qué un delay(10) no es la respuesta; y explicá por qué un bus con tres terminadores de 120 Ω no es correcto. (Para la primera: 5 · 60 / (1120 + 60) = 0,254 V.) Si podés justificar las tres respuestas, tenés la capa eléctrica de las redes industriales.

En el próximo tema vemos Modbus RTU, el protocolo que se monta sobre RS-485: tramas, funciones, registros, direcciones de esclavo, CRC y las consultas entre un maestro y sus esclavos.