CAN en la práctica: tiempo de bit, MCP2515, CAN FD y OBD-II

01 · Del protocolo al hardware

De la trama a la red real

En el tema 27 contamos los bits de una trama como si cada uno durara un tiempo exacto y todos los nodos los viesen igual. En la práctica no es así, y por tres motivos:

• Los relojes no son idénticos. Cada nodo tiene su propio oscilador, con una tolerancia (un cristal de cuarzo difiere unas decenas de partes por millón; un resonador cerámico, hasta medio por ciento). Después de varios bits la diferencia se acumula.
• La señal tarda en viajar. En el cable avanza unos 5 ns por metro, y los transceptores agregan retardos propios. Un nodo en un extremo recibe el bit de otro con una demora, y el arbitraje exige que la señal llegue y vuelva antes de leer el bus.
• No hay un reloj compartido. CAN es asíncrono: no hay línea de reloj. Los nodos se sincronizan con los propios flancos de los datos, que el relleno de bits garantiza que aparecen al menos cada seis bits (tema 27).

Todo esto se resuelve con una única decisión de diseño: dividir cada bit en cuantos de tiempo y repartirlos en cuatro segmentos. Ese reparto, que se carga en tres registros del controlador, es el tiempo de bit. Es la parte de CAN que más cuesta entender y la que más veces explica por qué una red «casi» anda.

02 · Dividir el bit

El tiempo de bit y el punto de muestreo

El controlador toma un reloj propio, el cuanto de tiempo (time quantum, Tq), que es el reloj del oscilador dividido por un prescaler. Un bit dura un número entero de cuantos, entre 8 y 25 según la norma, y se reparte en cuatro segmentos:

• Sync_Seg (1 Tq). Es donde se espera que ocurra el flanco de un bit. Sirve para sincronizar.
• Prop_Seg (1 a 8 Tq). Compensa el retardo de propagación: la señal sale del transmisor, recorre el cable, atraviesa el transceptor del receptor y vuelve. Tiene que cubrir el doble del retardo en un sentido.
• Phase_Seg1 (1 a 8 Tq). Primer segmento de fase. Se puede alargar durante la resincronización.
• Phase_Seg2 (2 a 8 Tq). Segundo segmento de fase. Se puede acortar durante la resincronización.

El punto de muestreo está justo entre Phase_Seg1 y Phase_Seg2: ahí el controlador lee el nivel del bus y decide si el bit fue 0 o 1. Se expresa como porcentaje del bit:

punto de muestreo = (1 + Prop_Seg + Phase_Seg1) / (1 + Prop_Seg + Phase_Seg1 + Phase_Seg2)

Cuanto más tarde se muestrea, más tiempo tuvo la señal para propagarse y estabilizarse, lo que es bueno para redes largas. Pero Phase_Seg2 queda más corto, y de él depende la capacidad de absorber diferencias de reloj (sección siguiente). Los valores usuales están entre el 75 % y el 90 %; las capas superiores suelen fijar el punto de muestreo (por ejemplo, 87,5 % es habitual en CANopen y J1939).

La velocidad resulta de dividir el reloj entre el prescaler y el número de cuantos del bit. Con un cristal de 16 MHz en un MCP2515, el cuanto dura 2 · (BRP + 1) / 16 MHz. Con BRP = 0, el cuanto dura 125 ns, y 16 cuantos por bit dan 2 µs, es decir 500 kbit/s. Con BRP = 1 el cuanto dura 250 ns y los mismos 16 cuantos dan 250 kbit/s. Y se puede obtener la misma velocidad con otros repartos: a 8 cuantos de 250 ns también se llega a 500 kbit/s, con menos resolución para ubicar el punto de muestreo.

Una condición más: el controlador necesita unos 2 Tq tras el punto de muestreo para procesar el bit, por eso Phase_Seg2 no baja de 2 Tq. También hay que respetar Phase_Seg2 ≤ Prop_Seg + Phase_Seg1, y el SJW (próxima sección) no puede superar a ninguno de los dos segmentos de fase.

03 · Mantener la sincronía

Sincronización y tolerancia del reloj

Cada nodo se sincroniza de dos maneras:

• Sincronización dura. Con el flanco recesivo→dominante del bit de inicio (SOF) de una trama, todos los nodos reinician su contador de bit: ese flanco define el comienzo del primer bit.
• Resincronización. Durante la trama, cada flanco recesivo→dominante que no cae exactamente en Sync_Seg indica que el reloj local va adelantado o atrasado respecto del emisor. El controlador corrige la fase: si el flanco llegó tarde (el receptor es más rápido), alarga Phase_Seg1; si llegó temprano (el receptor es más lento), acorta Phase_Seg2. La corrección máxima por flanco es el SJW (Synchronization Jump Width, de 1 a 4 Tq).

Como el relleno de bits obliga a un flanco al menos cada diez bits (cinco iguales, el insertado, y se repite), el receptor tiene oportunidades frecuentes de corregirse. La diferencia de reloj que el sistema tolera la fijan dos condiciones de la especificación de Bosch, con Nbt = cuantos por bit:

• Δf ≤ SJW / (20 · Nbt): la corrección por flanco (SJW) tiene que alcanzar a compensar el corrimiento acumulado en 10 bits (la distancia máxima entre flancos).
• Δf ≤ min(Phase_Seg1, Phase_Seg2) / (2 · (13 · Nbt − Phase_Seg2)): el corrimiento acumulado en hasta 13 bits sin un flanco útil no puede sacar el punto de muestreo de los segmentos de fase.

La tolerancia admisible del oscilador (en fracción de la frecuencia nominal) es la menor de las dos. Para Nbt = 16, Phase_Seg2 = 2 y SJW = 2, resulta ± 0,49 %: la segunda condición es la limitante, porque Phase_Seg2 es corto, y subir el SJW no ayuda. Si se pasa a Phase_Seg2 = 4 y SJW = 4, la tolerancia sube a ± 0,98 %, a costa de bajar el punto de muestreo del 87,5 % al 75 % con el mismo total.

Por eso los diseños de CAN usan casi siempre cristal, y por eso al usar el oscilador interno de un microcontrolador la comunicación funciona un rato y después empieza a fallar con la temperatura.

Dos detalles. La resincronización solo actúa con flancos recesivo→dominante, y a lo sumo una vez por bit. Y algunos controladores, como el MCP2515, ofrecen muestreo triple (SAM): el bit se lee tres veces, en instantes muy próximos justo antes del punto de muestreo, y vale la mayoría. Filtra picos de ruido breves.

04 · Elegir los valores

Elegir los parámetros

El procedimiento para configurar un nodo es el siguiente, en este orden:

1. Elegir la velocidad según la longitud y el uso (tema 27): 500 kbit/s en automoción, 250 kbit/s en maquinaria, 125 kbit/s o menos para cables largos.
2. Elegir el oscilador y el prescaler para tener el mayor número de cuantos por bit posible (hasta 25) con una velocidad exacta: cuantos por bit = fosc / (2 · (BRP + 1) · velocidad) debe dar entero.
3. Repartir los cuantos: Phase_Seg2 de al menos 2 Tq (en general, el 12,5 % al 25 % del bit), el resto entre Prop_Seg y Phase_Seg1, hasta que el punto de muestreo quede en el valor recomendado para la red.
4. Comprobar el retardo de propagación: el punto de muestreo no puede caer antes de que la señal haya hecho el recorrido de ida y vuelta.
5. Comprobar la tolerancia: el valor que dan las dos condiciones de la sección anterior tiene que superar la tolerancia real de los osciladores de la red, con holgura.
6. Usar la misma configuración en todos los nodos, o al menos la misma velocidad y un punto de muestreo parecido.

Para el retardo usamos un modelo simple: el cable aporta unos 5 ns por metro (en cada sentido) y los transceptores de los dos extremos unos 250 ns cada uno. El tiempo de ida y vuelta es entonces 10 ns · L + 500 ns. Esa cuenta da 900 ns para 40 m, 1500 ns para 100 m y 2500 ns para 200 m. El punto de muestreo, medido desde el comienzo del bit, tiene que caer después: en el ejemplo de 500 kbit/s con 16 Tq de 125 ns, el muestreo ocurre a los 14 Tq = 1750 ns, y alcanza para 100 m pero no para 200 m. Este razonamiento explica las reglas de longitud del tema 27: la longitud máxima baja cuando sube la velocidad, porque el bit se acorta y el retardo no.

La tabla siguiente muestra los valores que da el procedimiento anterior (la herramienta 2 del laboratorio) para los cristales más comunes en los módulos MCP2515, con un punto de muestreo buscado del 87,5 %:

Observá que a 16 MHz y 500 kbit/s las dos opciones (BRP = 0 con 16 Tq o BRP = 1 con 8 Tq) dan la misma velocidad, pero la primera permite ubicar el punto de muestreo al 87,5 % y la segunda solo al 75 %. Los valores de las bibliotecas más conocidas pueden diferir de estos: la velocidad es la misma, pero reparten los segmentos de otra manera (con otro punto de muestreo). Mientras todos los nodos tengan el mismo bit y un punto de muestreo parecido, funciona.

05 · El chip del bus

Transceptores y capa física

El transceptor (transceiver) es el circuito que convierte las señales digitales TX y RX del controlador en los niveles diferenciales del bus, y viceversa. Hace tres trabajos: maneja CANH y CANL con el dominante cuando TX está en 0; entrega a RX el nivel que ve en el bus (incluido lo que él mismo transmitió, porque el arbitraje necesita comparar), y protege el controlador: soporta cortocircuitos a masa o a la batería, picos de tensión y sobretemperatura. Tiene cuatro o cinco terminales de control: TXD, RXD, CANH, CANL, la alimentación, y según el modelo, un pin de modo (standby) o de control de pendiente (Rs).

Cinco decisiones prácticas de capa física:

• Tensión de la lógica. Un transceptor de 5 V (MCP2551, TJA1050) tiene entradas y salidas de 5 V. Si el controlador es de 3,3 V, hace falta un modelo de 3,3 V o un adaptador de nivel; de lo contrario RXD de 5 V puede dañar la entrada del ESP32.
• Pendiente de los flancos. Flancos más suaves (resistencia en Rs) reducen la emisión de interferencia, pero retardan la señal y consumen tiempo de propagación. Para redes largas y lentas conviene suavizar; en redes cortas y rápidas, no.
• Terminación partida (split termination). Se reemplaza el resistor de 120 Ω por dos de 60 Ω en serie, con el punto medio conectado a masa a través de un capacitor (por ejemplo 4,7 nF). Mantiene la terminación de 120 Ω para la señal diferencial y deriva a masa el ruido de modo común.
• Filtro de modo común y protección. En ambientes ruidosos se agregan un inductor de modo común en la entrada del bus y diodos supresores (TVS) para descargas electrostáticas.
• Aislamiento galvánico. Cuando los nodos tienen masas distintas (distintos tableros, motores, tierras), una diferencia de potencial entre ellas puede superar el rango de modo común (aproximadamente de −2 V a +7 V). Un transceptor aislado separa los dominios.

El mismo bus puede tener nodos con transceptores de distintas marcas, siempre que cumplan ISO 11898-2. En una red CAN FD todos los transceptores tienen que soportar la velocidad de datos.

06 · CAN para cualquier microcontrolador

El controlador MCP2515

El MCP2515 de Microchip es un controlador CAN 2.0B independiente: cualquier microcontrolador con SPI le agrega un puerto CAN. Es la forma más barata de usar CAN en un Arduino, y existen módulos listos que combinan el MCP2515, un transceptor TJA1050, un cristal y el conector de bornes. Lo que ofrece:

• Arbitraje, relleno de bits, CRC, ACK, errores y contadores, en hardware, como cualquier controlador CAN.
• Tres buffers de transmisión (TXB0 a TXB2), con prioridad configurable, y dos buffers de recepción (RXB0 y RXB1), con la posibilidad de que RXB0 desborde a RXB1 (rollover).
• Dos máscaras y seis filtros de aceptación: la máscara 0 y los filtros 0 y 1 actúan sobre RXB0; la máscara 1 y los filtros 2 a 5, sobre RXB1. Con las convenciones del tema 27: un bit de la máscara en 1 significa «comparar».
• Interfaz SPI de hasta 10 MHz (modos 0,0 y 1,1), un pin de interrupción INT (activo en bajo) y pines opcionales para solicitar la transmisión o avisar la recepción.
• Cinco modos: configuración (al encender; ahí se cargan velocidad, filtros y máscaras), normal, sueño, solo escucha (recibe pero nunca transmite ni confirma: ideal para espiar un bus) y lazo cerrado (loopback: lo que transmite se recibe internamente, sin transceptor ni bus, para probar el SPI).

El microcontrolador maneja el chip con instrucciones SPI de un byte, seguidas de direcciones y datos, siempre con CS en bajo durante toda la instrucción:

Los registros que se tocan con más frecuencia son estos:

El identificador estándar de 11 bits se reparte entre dos registros: SIDH = id >> 3 (los 8 bits altos) y SIDL = (id & 7) << 5 (los 3 bajos, en la parte alta del byte; el bit 3 de SIDL, EXIDE, indica formato extendido). Para el identificador 0x123: SIDH = 0x24, SIDL = 0x60.

Ventajas del MCP2515: cuesta poco, es muy común y tiene bibliotecas para Arduino, ESP32, Raspberry Pi y otras placas. Limitaciones: la interfaz SPI y el número de buffers limitan el tráfico que se puede atender (a 500 kbit/s con tramas cortas, conviene usar la interrupción y leer rápido), no soporta CAN FD (para eso existe el MCP2518FD, también por SPI), y la carga de configuración es manual. En un ESP32 no es necesario: el TWAI integrado (tema 27) tiene la misma función sin SPI.

07 · Más datos, más rápido

CAN FD

CAN FD (Flexible Data-rate) es la evolución de CAN que Bosch presentó en 2012 y la ISO 11898-1 incorporó después. Mantiene el arbitraje y la capa física y cambia dos cosas de la trama:

• Dos velocidades. El arbitraje (el identificador) se hace a la velocidad nominal de siempre, porque necesita que todos los nodos «vean» cada bit al mismo tiempo. Pero una vez que un nodo ganó, no hay más contienda: la parte de datos puede ir a una velocidad mayor (2, 5 y hasta 8 Mbit/s según el transceptor). El cambio lo señala el bit BRS (Bit Rate Switch) y se vuelve a la velocidad nominal en el delimitador del CRC.
• Hasta 64 bytes por trama en lugar de 8. El código de longitud (DLC) sigue teniendo 4 bits: de 0 a 8 vale lo mismo, y de 9 a 15 representa 12, 16, 20, 24, 32, 48 y 64 bytes.

Los bits nuevos de la trama son FDF (recesivo: «esta es una trama CAN FD»; en CAN clásico, ese bit es el reservado r0 y va dominante), BRS (recesivo: cambiar a la velocidad de datos), ESI (Error State Indicator: el transmisor avisa si está en error pasivo) y un reemplazo del RTR (RRS), porque en CAN FD no hay tramas remotas. Además cambia el CRC: de 17 bits para tramas de hasta 16 bytes y de 21 bits para las mayores, con polinomios propios, y precedido por un campo de 4 bits que lleva la cuenta de bits de relleno. En el campo de CRC se usa relleno fijo (un bit de relleno cada cuatro bits), en lugar del relleno dinámico.

La duración se calcula en dos partes. Los bits de arbitraje y de cierre (30 bits sin relleno para el formato estándar: inicio, identificador, control hasta BRS, delimitador de CRC, ACK, fin de trama y separación) van a velocidad nominal. Los bits de la fase de datos son ESI (1), DLC (4), los datos (8 por byte), el contador de relleno (4), el CRC (17 o 21) y los bits de relleno fijo. Ejemplo con 8 bytes, 500 kbit/s nominal y 2 Mbit/s de datos: 30 bits nominales (60 µs) y 96 bits de datos (48 µs) hacen 108 µs, frente a los 222 µs de una trama clásica del mismo contenido. Con 64 bytes: 549 bits de datos y 334,5 µs frente a 1776 µs de ocho tramas clásicas, 5,3 veces más rápido. Con la fase de datos a 5 Mbit/s, son 169,8 µs, 10,5 veces menos. (No incluye el relleno dinámico, que agrega algunos bits más.) La ganancia crece con el tamaño de los datos porque el encabezado, que va lento, se reparte entre más bytes.

Consecuencias prácticas:

• Compatibilidad hacia atrás, no hacia adelante. Un controlador CAN FD entiende CAN clásico y conviven en un mismo bus mientras nadie envíe tramas FD. Un nodo de CAN clásico que ve una trama FD la interpreta como un error y manda una trama de error, destruyéndola. En una red mixta, los nodos FD tienen que enviar tramas clásicas, o hay que migrar todo junto (o configurar los clásicos en «solo recepción»).
• El tiempo de bit es más exigente en la fase de datos: los bits duran mucho menos y la tolerancia de los osciladores y la calidad de la señal pesan más. Se configuran dos tiempos de bit, el nominal y el de datos, y los transceptores y el cableado tienen que estar especificados para la velocidad de datos. Los controladores FD incorporan además la compensación del retardo del transmisor (transmitter delay compensation), para leer el bit propio a la velocidad de datos.
• Mejor eficiencia. Con 64 bytes, los bits que no son datos son alrededor del 12 % de la trama; con 8 bytes en CAN clásico, alrededor del 42 %.
• ISO y no ISO. Existen dos versiones incompatibles del formato del CRC (la original de Bosch y la normalizada en ISO 11898-1:2015). Los dispositivos nuevos usan la ISO.

CAN FD se usa en los vehículos nuevos y en la industria. Hay microcontroladores con controlador FD integrado, y controladores externos por SPI como el MCP2518FD. El TWAI de un ESP32 clásico no lo soporta.

08 · El conector de todos los autos

OBD-II: diagnóstico de vehículos

OBD-II (On-Board Diagnostics, segunda generación) es el estándar que permite a cualquier herramienta leer datos de motor y emisiones de un vehículo a través de un conector normalizado (SAE J1962, de 16 pines) bajo el tablero. Es obligatorio por regulación de emisiones: en los vehículos vendidos en EE. UU. desde 2008 el protocolo de capa de enlace es CAN (ISO 15765-4) y es el que usan casi todos los vehículos actuales. En ese conector, el pin 6 es CAN High, el 14 es CAN Low, los pines 4 y 5 son masa y el 16 es la batería (+12 V). La velocidad es de 500 kbit/s o 250 kbit/s, según el vehículo, con identificadores de 11 o de 29 bits.

OBD-II define servicios (modos) y, dentro del modo 01 (datos actuales), los PID (Parameter ID), códigos de un byte que identifican cada dato:

La conversación es de pregunta y respuesta. La herramienta (el «tester») envía una trama de 8 bytes con el identificador 0x7DF (la dirección funcional: es una petición a todas las centrales a la vez). El primer byte es el largo de lo que sigue; después el modo y el PID. La central que tiene el dato contesta con un identificador de su propia dirección, 0x7E8 para la primera (central del motor), 0x7E9 para la segunda, hasta 0x7EF. En la respuesta el modo vuelve sumado a 0x40 (0x41 para el modo 01) y se repite el PID, seguido de los bytes de datos. Un mensaje para una sola central usa su dirección física: 0x7E0 para la primera, y la respuesta vuelve con 0x7E8.

Los mensajes de más de 7 bytes (como el VIN, de 17 caracteres) no caben en una trama CAN. Se envían con el protocolo de transporte ISO-TP (ISO 15765-2), que divide el mensaje. El primer byte (o el primer nibble) de cada trama dice de qué tipo es:

• Trama única (0x0N): el mensaje cabe en una trama; N es el largo (así empieza 04 41 0C 1A F8).
• Primera trama (0x1 más 12 bits de largo): abre un mensaje largo y lleva los primeros 6 bytes.
• Control de flujo (0x30, bloque, separación mínima): lo envía el receptor para autorizar la continuación y fijar el ritmo.
• Trama consecutiva (0x2N): cada una lleva hasta 7 bytes y un número de secuencia N que cuenta de 1 a 15 y vuelve a 0.

Para el VIN (modo 09, PID 02), la central responde con una primera trama de largo 20 (10 14 49 02 01 …), el tester contesta 30 00 00 y las demás llegan en tramas 21, 22, etc.

OBD-II no es otro tipo de bus: es una capa de aplicación (qué servicios, qué PID, qué fórmula) sobre las tramas CAN de siempre. Lo mismo ocurre con los diagnósticos más amplios que usan los fabricantes (UDS, ISO 14229), que reutilizan ISO-TP con otros servicios.

09 · Máquinas, camiones y barcos

CAN en la industria

Fuera del automóvil de pasajeros, CAN se usa con capas superiores que fijan qué significa cada identificador y cómo se arma la red. Las dos más comunes:

J1939 (SAE) es la red de camiones, maquinaria agrícola y de construcción y motores marinos. Usa 250 kbit/s (y 500 kbit/s en versiones nuevas) con identificadores de 29 bits que se interpretan así:

El PGN (Parameter Group Number) identifica el grupo de señales que lleva la trama: se arma con EDP, DP y PF y, en PDU2, también con PS. Ejemplos: 0xF004 (EEC1, régimen y torque del motor, 61444), 0xFEF1 (CCVS, velocidad del vehículo, 65265) o 0xFEEE (temperaturas del motor, 65262). Una diferencia con lo visto hasta ahora es que en J1939 los nodos tienen dirección (SA) y la reclaman al encender con un mensaje Address Claimed (PGN 0xEE00): el identificador sigue describiendo el contenido, pero el origen forma parte de él.

CANopen (CiA 301) es el estándar de automatización industrial y de máquinas, con un modelo de objetos (un «diccionario» por dispositivo) y identificadores de 11 bits que combinan una función con el número de nodo (de 1 a 127):

Observá cómo se aplica la prioridad del tema 27: los mensajes de control de red (NMT, SYNC) tienen los identificadores más bajos, los de proceso (PDO) están después, y la configuración (SDO) y el latido van al final. Otras redes industriales sobre CAN son DeviceNet y NMEA 2000 (náutica), esta última basada en J1939.

Buenas prácticas de instalación:

• Cable. Par trenzado de 120 Ω con malla, y un tercer conductor de referencia en redes con nodos de masas distintas. Los conectores más comunes son DB9 (con CAN_L en el pin 2, CAN_H en el 7 y masa en el 3, según CiA 303-1) y M12 de 5 polos; verificá el cableado del fabricante.
• Topología. Bus lineal con dos terminadores, derivaciones lo más cortas posible (del orden de decenas de centímetros a 1 Mbit/s y de pocos metros a 125 kbit/s) y sin estrellas.
• Masa y malla. Evitar lazos de masa. La malla se conecta a tierra siguiendo la guía del sistema (en un punto, o a ambos extremos mediante capacitor); y con diferencias de potencial entre tableros, aislar los transceptores.
• Longitud y velocidad. Empezar por la velocidad más baja que sirva (tema 27, sección 09): reduce la sensibilidad al ruido y a los defectos del cableado.
• Supervisión. Los nodos envían un latido periódico; la ausencia de latido indica que un nodo cayó. El maestro lleva el estado de la red.
• Bus apagado. Un nodo que pasa a bus-off (tema 27) no vuelve solo en muchos controladores: la aplicación decide si reiniciar el controlador, cuándo y cuántas veces, y registra el evento. Reintentar sin límite un nodo defectuoso es lo que convierte una falla local en una perturbación de la red.

10 · Con el microcontrolador

Con el microcontrolador

El primer programa maneja un MCP2515 «a mano», con las instrucciones SPI de la sección 06, para que se vea qué hace una biblioteca. Configura 500 kbit/s con un cristal de 16 MHz (los valores de la tabla de la sección 04), transmite cada 100 ms un mensaje de identificador 0x200 con un contador, y muestra lo que recibe. Con el valor de MODO en 0x40 (lazo cerrado) se puede probar con un solo módulo y sin nadie más en el bus:

#include <SPI.h>

const int PIN_CS = 5;                           // chip select del MCP2515
const uint8_t MODO = 0x00;                      // 0x00 normal · 0x40 lazo cerrado (prueba sin bus) · 0x60 solo escucha

// Instrucciones SPI y registros del MCP2515
const uint8_t CMD_RESET = 0xC0, CMD_READ = 0x03, CMD_WRITE = 0x02;
const uint8_t CMD_LOAD_TXB0 = 0x40, CMD_RTS_TXB0 = 0x81, CMD_READ_RXB0 = 0x90;
const uint8_t CNF3 = 0x28, CNF2 = 0x29, CNF1 = 0x2A, CANINTF = 0x2C, CANSTAT = 0x0E, CANCTRL = 0x0F, TXB0CTRL = 0x30, RXB0CTRL = 0x60;

SPISettings ajuste(4000000, MSBFIRST, SPI_MODE0);

void escribir(uint8_t reg, uint8_t valor) {
    SPI.beginTransaction(ajuste);
    digitalWrite(PIN_CS, LOW);
    SPI.transfer(CMD_WRITE); SPI.transfer(reg); SPI.transfer(valor);
    digitalWrite(PIN_CS, HIGH);
    SPI.endTransaction();
}

uint8_t leer(uint8_t reg) {
    SPI.beginTransaction(ajuste);
    digitalWrite(PIN_CS, LOW);
    SPI.transfer(CMD_READ); SPI.transfer(reg);
    uint8_t valor = SPI.transfer(0);
    digitalWrite(PIN_CS, HIGH);
    SPI.endTransaction();
    return valor;
}

bool iniciarMcp() {
    SPI.beginTransaction(ajuste);
    digitalWrite(PIN_CS, LOW); SPI.transfer(CMD_RESET); digitalWrite(PIN_CS, HIGH);
    SPI.endTransaction();
    delay(10);                                  // tras el reset queda en modo configuración
    escribir(CNF1, 0x40);                       // SJW = 2 Tq, BRP = 0: Tq = 125 ns con 16 MHz
    escribir(CNF2, 0xAE);                       // BTLMODE = 1, muestreo simple, PS1 = 6 Tq, Prop = 7 Tq
    escribir(CNF3, 0x01);                       // PS2 = 2 Tq: 16 Tq por bit = 500 kbit/s, muestreo al 87,5 %
    escribir(RXB0CTRL, 0x60);                   // sin filtros: acepta todas las tramas
    escribir(CANCTRL, MODO);                    // sale del modo configuración
    for (int i = 0; i < 100; i++) {             // el chip espera 11 bits recesivos antes de cambiar de modo
        if ((leer(CANSTAT) & 0xE0) == (MODO & 0xE0)) return true;
        delay(1);
    }
    return false;
}

bool enviar(uint16_t id, const uint8_t *datos, uint8_t n) {
    if (leer(TXB0CTRL) & 0x08) return false;    // TXREQ: la trama anterior sigue pendiente (por ejemplo, sin ACK)
    SPI.beginTransaction(ajuste);
    digitalWrite(PIN_CS, LOW);
    SPI.transfer(CMD_LOAD_TXB0);                // carga desde TXB0SIDH
    SPI.transfer(id >> 3);                      // SIDH: los 8 bits altos del identificador
    SPI.transfer((id & 0x07) << 5);            // SIDL: los 3 bajos, formato estándar
    SPI.transfer(0); SPI.transfer(0);           // EID8 y EID0: no se usan
    SPI.transfer(n);                            // DLC
    for (uint8_t i = 0; i < n; i++) SPI.transfer(datos[i]);
    digitalWrite(PIN_CS, HIGH);
    digitalWrite(PIN_CS, LOW); SPI.transfer(CMD_RTS_TXB0); digitalWrite(PIN_CS, HIGH);   // pide la transmisión
    SPI.endTransaction();
    return true;
}

bool recibir(uint16_t &id, uint8_t *datos, uint8_t &n) {
    if (!(leer(CANINTF) & 0x01)) return false;  // RX0IF: no hay nada en RXB0
    SPI.beginTransaction(ajuste);
    digitalWrite(PIN_CS, LOW);
    SPI.transfer(CMD_READ_RXB0);                // lee desde RXB0SIDH; al subir CS borra RX0IF
    uint8_t sidh = SPI.transfer(0), sidl = SPI.transfer(0);
    SPI.transfer(0); SPI.transfer(0);           // EID8 y EID0
    uint8_t dlc = SPI.transfer(0) & 0x0F;
    n = dlc > 8 ? 8 : dlc;
    for (uint8_t i = 0; i < n; i++) datos[i] = SPI.transfer(0);
    digitalWrite(PIN_CS, HIGH);
    SPI.endTransaction();
    if (sidl & 0x08) return false;              // trama extendida: este ejemplo la descarta
    id = ((uint16_t)sidh << 3) | (sidl >> 5);
    return true;
}

void setup() {
    Serial.begin(115200);
    pinMode(PIN_CS, OUTPUT); digitalWrite(PIN_CS, HIGH);
    SPI.begin();                                // ESP32: SCK 18, MISO 19, MOSI 23 (VSPI por defecto)
    if (!iniciarMcp()) { Serial.println("El MCP2515 no respondió: revisá el cableado, la tensión y el cristal"); while (true) delay(1000); }
    Serial.println("MCP2515 a 500 kbit/s (cristal de 16 MHz)");
}

void loop() {
    static unsigned long ultimo = 0;
    static uint16_t contador = 0;
    if (millis() - ultimo >= 100) {
        ultimo = millis();
        uint8_t d[2] = { (uint8_t)(contador >> 8), (uint8_t)(contador & 0xFF) };
        if (enviar(0x200, d, 2)) contador++;
        else Serial.println("La trama anterior sigue pendiente: ¿hay otro nodo que dé el ACK?");
    }
    uint16_t id; uint8_t n, datos[8];
    if (recibir(id, datos, n)) {
        Serial.print("id 0x"); Serial.print(id, HEX); Serial.print(" datos");
        for (uint8_t i = 0; i < n; i++) { Serial.print(' '); if (datos[i] < 16) Serial.print('0'); Serial.print(datos[i], HEX); }
        Serial.println();
    }
}

Dos comentarios sobre el programa. Primero, la configuración solo se acepta en modo configuración (al encender y después de un reset): una vez que se pasa a normal, los registros CNF y los filtros no se pueden cambiar sin volver a configuración (CANCTRL = 0x80). Segundo, en el modo normal sin nadie que confirme, la trama queda pendiente (el bit TXREQ no baja) y el programa lo detecta y no la pisa. Para recibir solo un rango de identificadores, por ejemplo 0x200 a 0x20F, se configuran la máscara y los filtros (también en modo configuración) y se pone RXM en 00:

escribir(0x20, 0xFE); escribir(0x21, 0x00);   // RXM0: máscara 0x7F0 (SIDH = 0x7F0 >> 3, SIDL = 0)
escribir(0x00, 0x40); escribir(0x01, 0x00);   // RXF0: código 0x200 (SIDH = 0x40), solo formato estándar
escribir(0x04, 0x40); escribir(0x05, 0x00);   // RXF1: el mismo, así RXB0 no deja pasar nada más
escribir(RXB0CTRL, 0x00);                     // RXM = 00: usar la máscara y los filtros

El segundo programa es un consultor OBD-II para un ESP32 con el controlador TWAI y un transceptor de 3,3 V. Pide cada segundo el régimen del motor y la velocidad, y decodifica la respuesta. El filtro deja pasar solo los identificadores 0x7E8 a 0x7EF. Es de solo lectura (modo 01):

#include "driver/twai.h"

void consultar(uint8_t pid) {
    twai_message_t m = {};
    m.identifier = 0x7DF;                                       // dirección funcional: contestan las centrales que tengan el dato
    m.data_length_code = 8;
    m.data[0] = 0x02; m.data[1] = 0x01; m.data[2] = pid;        // dos bytes útiles: modo 01 y el PID
    twai_transmit(&m, pdMS_TO_TICKS(50));
}

void setup() {
    Serial.begin(115200);
    twai_general_config_t general = TWAI_GENERAL_CONFIG_DEFAULT(GPIO_NUM_5, GPIO_NUM_4, TWAI_MODE_NORMAL);
    twai_timing_config_t tiempos = TWAI_TIMING_CONFIG_500KBITS();   // algunos vehículos usan 250 kbit/s
    twai_filter_config_t filtro;
    filtro.acceptance_code = (uint32_t)0x7E8 << 21;
    filtro.acceptance_mask = ~((uint32_t)0x7F8 << 21);           // 0x7E8 a 0x7EF (aquí un 1 = «no importa»)
    filtro.single_filter = true;
    if (twai_driver_install(&general, &tiempos, &filtro) != ESP_OK || twai_start() != ESP_OK) {
        Serial.println("No se pudo iniciar el controlador CAN");
        while (true) delay(1000);
    }
}

void loop() {
    static unsigned long ultimo = 0;
    static bool pedirRegimen = true;
    if (millis() - ultimo >= 1000) {
        ultimo = millis();
        consultar(pedirRegimen ? 0x0C : 0x0D);
        pedirRegimen = !pedirRegimen;
    }
    twai_message_t r;
    if (twai_receive(&r, pdMS_TO_TICKS(50)) == ESP_OK && r.data_length_code >= 4 && r.data[1] == 0x41) {
        if (r.data[2] == 0x0C && r.data[0] >= 4) {
            Serial.print("Regimen: "); Serial.print(((r.data[3] * 256) + r.data[4]) / 4.0, 1); Serial.println(" rpm");
        } else if (r.data[2] == 0x0D) {
            Serial.print("Velocidad: "); Serial.print(r.data[3]); Serial.println(" km/h");
        }
    }
}

Si el vehículo no responde: comprobá primero la velocidad (500 o 250 kbit/s), que haya contacto, que los cables estén en los pines 6 y 14 y que el transceptor sea de 3,3 V. Algunos vehículos solo atienden un identificador de 29 bits (0x18DB33F1, la dirección funcional extendida de ISO 15765-4), lo que requiere m.extd = 1.

11 · Analogía con programación

CAN en la práctica, en Python

Las cuentas de esta sección (tiempo de bit y registros del MCP2515, búsqueda de una configuración, duración de una trama CAN FD, decodificación OBD-II y J1939) son pura aritmética y caben en pocas líneas. El modelo siguiente calcula el punto de muestreo y la tolerancia, arma los registros CNF1 a CNF3, busca una configuración para un cristal y una velocidad dados, compara una trama CAN FD con CAN clásico, decodifica un régimen de motor y descompone un identificador J1939.

def tiempo_de_bit(fosc, brp, prop, ps1, ps2, sjw):
    total = 1 + prop + ps1 + ps2
    tq = 2 * (brp + 1) / fosc
    velocidad = fosc / (2 * (brp + 1) * total)
    muestreo = (1 + prop + ps1) / total * 100
    tol_sjw = sjw / (20 * total) * 100
    tol_fase = min(ps1, ps2) / (2 * (13 * total - ps2)) * 100
    return tq, total, velocidad, muestreo, min(tol_sjw, tol_fase)


def registros(brp, prop, ps1, ps2, sjw):
    cnf1 = ((sjw - 1) << 6) | brp
    cnf2 = 0x80 | ((ps1 - 1) << 3) | (prop - 1)
    cnf3 = ps2 - 1
    return cnf1, cnf2, cnf3


def retardo_ns(largo_m):
    return 10 * largo_m + 500                          # cable de ida y vuelta + transceptores de los dos nodos


def buscar(fosc, velocidad, muestreo):
    for b in range(1, 65):
        if fosc % (2 * b * velocidad) == 0 and 8 <= fosc // (2 * b * velocidad) <= 25:
            total = fosc // (2 * b * velocidad)
            break
    else:
        return None
    ps2 = int(total * (1 - muestreo / 100) + 0.5)
    ps2 = min(max(ps2, 2, total - 17), 8, (total - 1) // 2)
    resto = total - 1 - ps2
    prop = min(8, -(-resto // 2))
    return b - 1, prop, resto - prop, ps2, min(4, ps2)


def trama_fd(n, nominal, datos):
    crc = 21 if n > 16 else 17
    fijos = -(-(4 + crc) // 4)
    bits_datos = 1 + 4 + 8 * n + 4 + crc + fijos
    return bits_datos, (30 / nominal + bits_datos / datos) * 1e6


def tiempo_clasico(n, velocidad):
    bits = (n // 8) * 111 + (47 + 8 * (n % 8) if n % 8 else 0)
    return bits / velocidad * 1e6


def obd_regimen(a, b):
    return (256 * a + b) / 4


def j1939(identificador):
    prioridad = (identificador >> 26) & 7
    pf = (identificador >> 16) & 0xFF
    ps = (identificador >> 8) & 0xFF
    pgn = (((identificador >> 24) & 3) << 16) | (pf << 8) | (ps if pf >= 240 else 0)
    return prioridad, pgn, identificador & 0xFF, ps


tq, total, v, m, tol = tiempo_de_bit(16e6, 0, 7, 6, 2, 2)
print(f"16 MHz, BRP 0, segmentos 1+7+6+2, SJW 2: Tq {tq * 1e9:.0f} ns, {total} Tq, {v / 1000:.0f} kbit/s, muestreo {m:.1f} %, tolerancia ± {tol:.2f} %")
print("  registros:", ", ".join(f"{r:#04x}" for r in registros(0, 7, 6, 2, 2)))
tq, total, v, m, tol = tiempo_de_bit(16e6, 0, 3, 8, 4, 4)
print(f"Con segmentos 1+3+8+4 y SJW 4: muestreo {m:.1f} %, tolerancia ± {tol:.2f} %  (más tolerancia, muestreo más temprano)")
print("Retardo de ida y vuelta (ns) para 40, 100 y 200 m:", [retardo_ns(L) for L in (40, 100, 200)], "frente a 1750 ns hasta el punto de muestreo")
for fosc, vel in ((16_000_000, 500000), (8_000_000, 125000), (20_000_000, 250000), (8_000_000, 1000000)):
    print(f"Cristal de {fosc / 1e6:.0f} MHz a {vel // 1000} kbit/s ->", buscar(fosc, vel, 87.5))

print()
for n, nom, dat in ((8, 500000, 2000000), (64, 500000, 2000000), (64, 500000, 5000000)):
    bits, t = trama_fd(n, nom, dat)
    c = tiempo_clasico(n, nom)
    print(f"FD de {n} bytes, {nom // 1000} kbit/s + {dat // 1000000} Mbit/s: {bits} bits de datos, {t:.1f} µs; clásico {c:.0f} µs; {c / t:.2f} veces más rápido")

print()
a, b = 0x1A, 0xF8
print(f"OBD-II: A=0x1A, B=0xF8 -> {obd_regimen(a, b):.0f} rpm; 0x3C -> {0x3C} km/h; 0x7B -> {0x7B - 40} °C; 0x80 -> {0x80 * 100 / 255:.1f} %")
for ident in (0x18FEF100, 0x18EA0B00):
    prioridad, pgn, sa, ps = j1939(ident)
    print(f"J1939 {ident:#010x}: prioridad {prioridad}, PGN {pgn:#06x} ({pgn}), origen {sa:#04x}, PS {ps:#04x}")

Resultado: con un cristal de 16 MHz, BRP 0 y segmentos 1 + 7 + 6 + 2 con SJW 2, el cuanto dura 125 ns, el bit tiene 16 Tq, la velocidad es de 500 kbit/s, el punto de muestreo está en el 87,5 % y la tolerancia del oscilador es de ± 0,49 %; los registros del MCP2515 son 0x40, 0xae y 0x01. Con segmentos 1 + 3 + 8 + 4 y SJW 4, el muestreo baja a 75,0 % y la tolerancia sube a ± 0,98 %. El retardo de ida y vuelta es de 900 ns para 40 m, 1500 ns para 100 m y 2500 ns para 200 m, frente a los 1750 ns que hay hasta el punto de muestreo. La búsqueda da, para 16 MHz y 500 kbit/s, BRP 0 con Prop 7, PS1 6, PS2 2 y SJW 2; para 8 MHz y 125 kbit/s, BRP 1 con los mismos segmentos; para 20 MHz y 250 kbit/s, BRP 1 con Prop 8, PS1 8, PS2 3 y SJW 3; y ninguna solución para 8 MHz y 1 Mbit/s. Una trama FD de 8 bytes a 500 kbit/s más 2 Mbit/s tiene 96 bits de datos y dura 108,0 µs, frente a 222 µs en CAN clásico (2,06 veces más rápida); una de 64 bytes tiene 549 bits de datos y dura 334,5 µs frente a 1776 µs (5,31 veces), y con 5 Mbit/s de datos dura 169,8 µs (10,46 veces). La respuesta OBD-II con A = 0x1A y B = 0xF8 es de 1726 rpm; 0x3C son 60 km/h, 0x7B son 83 °C y 0x80 es el 50,2 %. Y el identificador J1939 0x18fef100 tiene prioridad 6, PGN 0xfef1 (65265) y origen 0x00, mientras que el 0x18ea0b00 tiene prioridad 6, PGN 0xea00 (59904) y está dirigido al nodo 0x0b.

Observá que todo depende solo de números: cuantos, prescaler, bits. Un controlador hace esto por vos, pero en el momento de configurar un MCP2515, de leer una captura o de dimensionar una red hay que hacer estas cuentas.

12 · Exploración interactiva

Laboratorio: tiempo de bit, FD, OBD-II y J1939

El laboratorio tiene cinco herramientas. La primera calcula las características de un tiempo de bit (velocidad, punto de muestreo, tolerancia y registros del MCP2515) y lo valida contra la longitud del cable. La segunda busca una configuración para un cristal y una velocidad. La tercera calcula la duración y el rendimiento de una trama CAN FD. La cuarta arma una consulta OBD-II y decodifica la respuesta. La quinta descompone un identificador J1939 de 29 bits.

En la herramienta 1, el retardo usa el modelo de la sección 04 (10 ns por metro más 500 ns) y compara con el tiempo que hay hasta el punto de muestreo; la tolerancia es la de las dos condiciones de la sección 03; los registros suponen BTLMODE = 1 y muestreo simple. En la 2, el mayor número de cuantos por bit (de 8 a 25) que da una velocidad exacta. En la 3, los bits son los de formato estándar y no incluyen el relleno dinámico. En la 4, la respuesta se arma con relleno de ceros (cada fabricante rellena con su valor).

Recorrido guiado

1. Con los valores iniciales (16 MHz, BRP 0, segmentos 7 · 6 · 2, SJW 2, 40 m): cuanto de 125 ns, 16 Tq, 500 kbit/s, punto de muestreo del 87,5 %, retardo de 900 ns frente a 1750 ns hasta el muestreo, tolerancia de ± 0,49 % y registros CNF1 0x40 · CNF2 0xAE · CNF3 0x01. El veredicto es «Solo con cristal»: ± 0,49 % no alcanza para un resonador cerámico.
2. Subí Phase_Seg2 a 4, SJW a 4 y poné Prop_Seg en 3 y Phase_Seg1 en 8 (siguen sumando 16 Tq): el punto de muestreo baja a 75 % y la tolerancia sube a ± 0,98 %. «Configuración razonable»: se ganó tolerancia y se perdió punto de muestreo.
3. Con los valores iniciales, subí la longitud a 200 m: el retardo es 2500 ns y el muestreo cae a los 1750 ns, «No alcanza para ese cable». Con 100 m (1500 ns) vuelve a alcanzar. A BRP 1 la velocidad pasa a 250 kbit/s y el cuanto a 250 ns: el muestreo cae a los 3500 ns y entran 200 m.
4. Poné SJW 4 con Phase_Seg2 2: «Configuración inválida», porque el SJW no puede superar a Phase_Seg2.
5. En la herramienta 2, con los valores iniciales (16 MHz, 500 kbit/s, 87,5 %): BRP = 0, 16 Tq, segmentos 7 · 6 · 2, SJW 2, registros 0x40 · 0xAE · 0x01. Cambiá a 8 MHz: 8 Tq, 75 % y 0x40 · 0x8A · 0x01, tolerancia ± 0,98 %. Con 8 MHz y 1 Mbit/s no hay solución. Con 16 MHz, 1 Mbit/s, 8 Tq y 75 %.
6. Bajá el punto de muestreo buscado a 75 con 16 MHz y 500 kbit/s: PS2 = 4, SJW = 4, registros 0xC0 · 0xA5 · 0x03 y tolerancia ± 0,98 %.
7. En la herramienta 3, con los valores iniciales (64 bytes, 500 kbit/s y 2 Mbit/s): DLC 15, CRC de 21 bits, 30 bits nominales y 549 bits de datos, 334,5 µs, frente a 1776 µs de ocho tramas clásicas: 5,31 veces más rápido, 191,3 kB/s frente a 36,0 kB/s.
8. Cambiá la velocidad de datos a 5 Mbit/s: 169,8 µs, 10,46 veces. Poné BRS en No: todo va a 500 kbit/s, 1158 µs, solo 1,53 veces más rápido (la ganancia que queda viene de que FD gasta menos bits de encabezado por byte). Con 8 bytes y 2 Mbit/s: 96 bits de datos, 108 µs frente a 222 µs: 2,06 veces.
9. En la herramienta 4, con los valores iniciales (PID 0x0C, A = 1A, B = F8): consulta 02 01 0C 00 00 00 00 00 al identificador 0x7DF, respuesta 04 41 0C 1A F8 00 00 00 de 0x7E8 y 1726 rpm. Con A = 00 y B = 00 son 0 rpm (motor detenido); con FF y FF, el máximo, 16383,75 rpm. Con el PID 0x0D y A = 3C: 60 km/h. Con el PID 0x05 y A = 7B: 83 °C, y con A = 00, −40 °C.
10. En la herramienta 5, con 18FEF100: prioridad 6, PGN 0xFEF1 = 65265 (velocidad del vehículo), formato PDU2 (PF = 0xFE ≥ 240), origen 0x00 (motor n.º 1). Con 18EA0B00: PDU1, destino 0x0B, PGN 0xEA00 = 59904 (solicitud de PGN). Con 0CF00400: prioridad 3, PGN 0xF004 (régimen y torque del motor).

13 · Un procedimiento

Diagnóstico de una red CAN real

Cuando un nodo con MCP2515 o una red nueva no anda, se revisa en este orden:

1. Comprobar el SPI. Leer un registro que se pueda escribir (por ejemplo, escribir 0x55 en CNF1 y releer) antes de pensar en el bus. Si siempre lee 0x00 o 0xFF, el problema es el cableado, el chip select, la alimentación o la tensión de la lógica.
2. Probar en modo lazo cerrado. Con CANCTRL = 0x40, el chip recibe lo que transmite sin transceptor ni bus. Si anda, el controlador y la configuración están bien; el problema está en el transceptor, el cableado o la red.
3. Revisar el cristal y la velocidad. Comparar el cristal real con el que asume el código: con 8 MHz en lugar de 16 la velocidad sale a la mitad.
4. Medir el bus (tema 27): 60 Ω entre CANH y CANL con todo apagado, 2,5 V en reposo, y las formas de onda con un osciloscopio o un analizador lógico.
5. Mirar con un nodo en solo escucha o con una interfaz USB–CAN: las tramas deben verse bien formadas y confirmadas.
6. Comprobar el tiempo de bit en todos los nodos: misma velocidad, puntos de muestreo parecidos, tolerancia suficiente para los osciladores. Si funciona con cable corto y falla con cable largo, es el retardo.
7. Revisar los filtros del controlador, la carga del bus y los contadores de error.

14 · Comprensión

Confusiones frecuentes

15 · Práctica guiada

Predecí antes de comprobar

1. Prescaler

Un MCP2515 con cristal de 16 MHz tiene que trabajar a 250 kbit/s con 16 Tq por bit. ¿Qué BRP hace falta y cuánto dura el cuanto?

2. Punto de muestreo y tolerancia

Un bit de 10 Tq se reparte en 1 + 2 + 4 + 3 (Sync, Prop, PS1, PS2) con SJW 3. ¿Qué punto de muestreo tiene y qué tolerancia admite?

3. Longitud máxima

A 1 Mbit/s con 8 Tq por bit (punto de muestreo del 75 %), ¿qué longitud de cable admite el modelo de retardo (10 ns por metro más 500 ns)? ¿Y con el muestreo al 87,5 %?

4. Decodificar registros

Un MCP2515 de 16 MHz tiene CNF1 = 0x43, CNF2 = 0xAE y CNF3 = 0x01. ¿Qué velocidad y punto de muestreo configuran?

5. CAN FD

Una trama FD de 32 bytes con 500 kbit/s nominal y 4 Mbit/s de datos. ¿Cuánto dura (sin relleno dinámico) y cuántas veces más rápido es que enviar los mismos datos en cuatro tramas clásicas de 8 bytes a 500 kbit/s?

6. Respuesta OBD-II

La central del motor responde con 04 41 0C 0F A0 00 00 00 al identificador 0x7E8. ¿Qué dato es y cuánto vale?

7. Identificador J1939

Descomponé el identificador 0x0CF00400.

16 · Síntesis

Ideas para recordar

¿Listo para el siguiente tema?

Antes de avanzar, calculá cuántos cuantos de 125 ns entran en un bit a 500 kbit/s (16) y cuál es el punto de muestreo con Sync 1, Prop 7, PS1 6 y PS2 2 (87,5 %); decidí si una configuración que tolera ± 0,49 % sirve para un resonador cerámico (no: hace falta cristal o una configuración con PS2 más largo); y explicá por qué una trama CAN FD de 64 bytes es unas cinco veces más rápida que ocho tramas clásicas con la misma velocidad nominal. Si podés justificar las tres respuestas, tenés lo necesario para configurar y diagnosticar una red CAN real.

Con esto cerramos las redes de dos y de múltiples nodos sobre pares de cobre punto a punto o en bus. En el próximo tema pasamos a las redes de paquetes: Ethernet y el modelo de capas, con direcciones físicas, tramas, conmutadores y cómo se organiza la comunicación entre computadoras.