Cómo construir un bus CAN con ESP32

¡Hola equipo! Bienvenidos a otra lección avanzada en Ingtelecto Pro. Hoy vamos a desbloquear una de las características más potentes y profesionales del ESP32, una que a menudo se pasa por alto pero que es el estándar de oro en la industria automotriz e industrial: el Bus CAN.

Seguramente has conectado sensores por WiFi o Bluetooth, pero... ¿qué pasa cuando necesitas fiabilidad absoluta, cables largos y resistencia al ruido eléctrico? Ahí es donde entra el protocolo CAN. Hoy aprenderemos cómo construir una red CAN con ESP32 desde cero.

Este no es un tutorial más. Vamos a entender la arquitectura, por qué necesitamos un chip extra (Transceptor) y programaremos dos nodos para que "hablen" entre ellos. 🚗⚡

¡Prepárate! Vamos a dejar de jugar con juguetes y empezaremos a usar protocolos de grado industrial.

Materiales Necesarios

Para montar una red CAN funcional necesitamos mínimo dos nodos (dos ESP32). Aquí está la lista de compras para el laboratorio de hoy.

Conceptos Clave: TWAI y Transceptores

Antes de conectar cables, entendamos la "magia" oculta del ESP32.

1. El Controlador Oculto (TWAI)

El ESP32 ya tiene un "cerebro" CAN adentro. Espressif (el fabricante) lo llama TWAI (Two-Wire Automotive Interface), pero es 100% compatible con el estándar CAN 2.0.
Esto significa que el ESP32 sabe cómo generar los paquetes de datos, verificar errores y priorizar mensajes. ¡No necesitas gastar procesamiento de CPU en eso!

2. ¿Por qué necesitamos el módulo TJA1050?

Si el ESP32 ya tiene controlador CAN... ¿para qué compramos el módulo TJA1050?
Aquí está el truco: El ESP32 habla en voltaje lógico (3.3V y 0V). Pero el Bus CAN real funciona con voltaje diferencial para evitar el ruido.

• El ESP32 (Pines TX/RX): Genera la lógica.
• El TJA1050 (Transceptor): Traduce esa lógica a voltajes diferenciales (CAN_H y CAN_L) que pueden viajar cientos de metros sin corromperse.

3. La Resistencia de Terminación (120$\Omega$)

El Bus CAN es como una cuerda tensa. Si envías una vibración (señal) y la cuerda no está "atada" al final, la onda rebota y ensucia la comunicación. Para evitar este eco (reflexión), necesitamos poner una resistencia de 120 Ohms en cada extremo del bus.
Nota: Muchos módulos TJA1050 azules ya traen esta resistencia soldada (R2). ¡Revisa tu módulo!

Conexiones y Diagramas ⚙️

Vamos a conectar el ESP32 al módulo transceptor. Usaremos los pines GPIO 4 y GPIO 5, pero puedes definir otros por software si lo prefieres.

Tabla de Conexiones

Conecta ambos ESP32 exactamente igual siguiendo esta tabla:

Ojo: El TJA1050 requiere 5V para funcionar correctamente, aunque acepta la lógica de 3.3V del ESP32 en sus pines de datos. Aliméntalo desde el pin VIN (5V) del ESP32 si estás conectado por USB.

Diagrama de la Red

La conexión entre los dos módulos es lo más fácil del mundo:

• CAN H con CAN H
• CAN L con CAN L

Instalación de la Librería

No vamos a reinventar la rueda. Usaremos la librería más estable para Arduino IDE.

1. Ve a Programa > Incluir Librería > Administrar Bibliotecas.
2. Busca "CAN".
3. Instala la versión creada por Sandeep Mistry.

El Código (Sketch)

Para probar esto, convertiremos un ESP32 en el "Emisor" (Envía un 'Hola') y el otro en el "Receptor" (Muestra el mensaje).

Código A: El Emisor (Sender)

Sube este código al primer ESP32.

// TUTORIAL INGTELECTO.COM - BUS CAN CON ESP32

// NODO 1: EMISOR (SENDER)
#include <CAN.h>
// Definimos los pines para el controlador TWAI interno

#define TX_GPIO_NUM   5  // Conectar a CTX del módulo

#define RX_GPIO_NUM   4  // Conectar a CRX del módulo
void setup() {

  Serial.begin(115200);

  while (!Serial);
  Serial.println("Iniciando Transmisor CAN...");
  // Configurar pines personalizados

  CAN.setPins(RX_GPIO_NUM, TX_GPIO_NUM);
  // Iniciar el Bus a 500 kbps (Estándar automotriz)

  if (!CAN.begin(500E3)) {

    Serial.println("¡Error al iniciar CAN! Revisa conexiones.");

    while (1); // Bucle infinito de error

  }
  Serial.println("CAN Iniciado correctamente.");

}
void loop() {

  Serial.print("Enviando paquete... ");
  // 1. Iniciar paquete con ID 0x12 (Identificador único del mensaje)

  CAN.beginPacket(0x12);
  // 2. Escribir datos (Máximo 8 bytes por paquete estándar)

  CAN.print("Hola"); // Enviamos texto simple
  // 3. Finalizar y enviar

  CAN.endPacket();
  Serial.println("¡Enviado!");
  delay(1000); // Esperar 1 segundo

}

Código B: El Receptor (Receiver)

Sube este código al segundo ESP32.

// TUTORIAL INGTELECTO.COM - BUS CAN CON ESP32

// NODO 2: RECEPTOR (RECEIVER)
#include <CAN.h>
#define TX_GPIO_NUM   5

#define RX_GPIO_NUM   4
void setup() {

  Serial.begin(115200);

  while (!Serial);
  Serial.println("Iniciando Receptor CAN...");
  CAN.setPins(RX_GPIO_NUM, TX_GPIO_NUM);
  // IMPORTANTE: La velocidad debe ser idéntica al emisor (500E3)

  if (!CAN.begin(500E3)) {

    Serial.println("¡Error al iniciar CAN!");

    while (1);

  }
  Serial.println("Esperando mensajes...");

}
void loop() {

  // Intentar leer un paquete (si existe)

  int packetSize = CAN.parsePacket();
  if (packetSize) {

    // ¡Paquete recibido!

    Serial.print("Recibido '");
    // Identificar quién mandó el mensaje (ID)

    if (CAN.packetExtended()) {

      Serial.print("extended ");

    }
    // Leer el contenido

    while (CAN.available()) {

      Serial.print((char)CAN.read()); // Imprimir cada caracter

    }
    Serial.print("' del ID: 0x");

    Serial.println(CAN.packetId(), HEX);

  }

}

Solución de Problemas Comunes 🔧

El protocolo CAN es robusto, pero el hardware a veces nos juega malas pasadas. Si no funciona, revisa esto:

Conclusión y Reto