Si eres un apasionado de la tecnología y te encanta experimentar con Arduino, este artículo es perfecto para ti. En esta guía te mostraremos cómo crear tu propia red CAN utilizando módulos MCP2515 y Arduino. ¡Descubre cómo poner en práctica tus conocimientos y llevar tus proyectos al siguiente nivel!
Los coches solían disponer de más de 2.000 metros de cable que conectaban, por ejemplo, los interruptores del salpicadero directamente con los faros y las luces traseras. A medida que los automóviles se volvieron más complejos, esta simple lógica dejó de funcionar. En 1986, Bosch introdujo el sistema de bus CAN, que resolvió este problema y abarató y facilitó la fabricación de automóviles. CAN es ahora el estándar de la industria y se utiliza en todo, desde automóviles y camiones hasta autobuses, tractores, aviones y barcos.
Si sabe cómo leer y analizar mensajes CAN en su Arduino, puede obtener datos de su automóvil, como la temperatura del refrigerante, la posición del acelerador, la velocidad del vehículo y la velocidad del motor, y usarlos en sus proyectos de tablero.
El módulo de interfaz de bus CAN MCP2515 es la mejor solución para agregar conectividad CAN con interfaz SPI a su Arduino. Este tutorial le mostrará cómo conectar el módulo MCP2515 a un Arduino, pero primero una introducción rápida al protocolo CAN.
Conceptos básicos del sistema de bus CAN
Una red de área de controlador (bus CAN) es un estándar de comunicación que permite que los dispositivos del vehículo se comuniquen entre sí sin una computadora host.
Para comprender mejor el bus CAN, imagine su automóvil como un cuerpo humano. En este contexto, el bus CAN es el sistema nervioso.
De manera similar a cómo el sistema nervioso permite la comunicación entre diferentes partes del cuerpo, el bus CAN permite la comunicación entre diferentes buses CAN nodotambién conocido como Dispositivos de control electrónico. (o dispositivos de control).
Un automóvil moderno tiene más de 70 dispositivos de control, cada uno de los cuales es responsable de realizar una tarea específica. Aunque estos dispositivos de control pueden realizar una única tarea de manera eficiente, necesitan compartir información entre sí. Por ejemplo, la unidad de control del motor envía la velocidad actual del motor al grupo de instrumentos, donde se muestra en un tacómetro; De manera similar, el módulo de control de la puerta del conductor envía un mensaje al módulo de control de la puerta del pasajero para operar la ventana.
Los dispositivos de control están conectados al bus en uno Configuración multimaestro. Esto significa que cada dispositivo de control puede tomar el control del bus y enviar información (p. ej. datos de sensores) a través de él. Los datos enviados son aceptados por todos los demás dispositivos de control del bus CAN. Cada dispositivo de control puede entonces leer los datos y decidir si los acepta o los ignora.
Topología del bus CAN
La comunicación física se realiza a través del mazo de cables del bus CAN, que consta de dos líneas, PUEDE bajo Y PUEDE alto. Ambos cables están fuertemente trenzados para que la interferencia electromagnética afecte la señal en ambos cables por igual, minimizando así los errores.
Los otros extremos del cable están terminados con resistencias de 120 ohmios. Debido a que el bus CAN es un bus de datos de alta velocidad, si el bus no está terminado, la señal se reflejará e interferirá con la siguiente señal de datos en la línea, lo que potencialmente interrumpirá la comunicación y provocará que el bus falle.
señalización CAN
Para permitir la transmisión de datos en estas líneas, se cambian sus niveles de voltaje. Estos cambios en los niveles de voltaje luego se traducen en niveles lógicos que permiten que los nodos de la red se comuniquen entre sí.
Para transmitir un «1 lógico» en el bus CAN, el voltaje en ambas líneas se establece en 2,5 voltios (es decir, no hay diferencia de voltaje). Esta condición se conoce como condición recesivae indica que el bus CAN está disponible para su uso por cada nodo.
En cambio, para transmitir «0 lógico», la línea CAN alta se establece en 3,5 voltios y la línea CAN baja en 1,5 voltios (es decir, hay una diferencia de voltaje de 2 V). Este estado del autobús se conoce como Estado dominanteque le dice a cada nodo en el bus que otro nodo está transmitiendo y que espere a que se complete la transmisión antes de enviar su mensaje.
Nodo de bus CAN
Cada nodo CAN contiene un transceptor CAN, un controlador CAN y un microcontrolador.
Un transceptor CAN
- Al recibir: Convierte los niveles de voltaje en el bus CAN en valores que el controlador CAN pueda entender.
- Al enviar: convierte el flujo de datos del controlador CAN en niveles de bus CAN.
Un controlador CAN
- Al enviar: Transmite el mensaje del microcontrolador al bus en serie cuando el bus está libre.
- Al recibir: almacena los bits en serie recibidos del bus hasta que esté disponible un mensaje completo e indica al microcontrolador que lo recupere (generalmente activando una interrupción).
un microcontrolador
Decide qué significan los mensajes que recibe y qué mensajes quiere transmitir. A él se conectan sensores, actuadores y dispositivos de control.
Un marco CAN estándar
La comunicación a través del bus CAN se realiza a través de marcos CAN. Aquí hay una trama CAN estándar con un identificador de 11 bits. Echemos un vistazo rápido a cada uno de los ocho campos de mensaje:
- SOF: El inicio de la trama es un «0 dominante» para indicar a los otros nodos que un nodo CAN quiere comunicarse.
- IDENTIFICACIÓN: El ID es el ID del marco. Se utiliza para indicar qué significa el mensaje y quién lo envía. El ID también define la prioridad: cuanto menor sea el ID, mayor será la prioridad del mensaje.
- RTR: La solicitud de transmisión remota indica si un nodo está enviando datos o solicitando datos de otro nodo.
- control: El controlador incluye el Bit de extensión de identificador (IDE), que es un «0 dominante» para 11 bits. También contiene el código de longitud de datos (DLC) de 4 bits, que indica cuántos bytes de datos se incluirán en el mensaje.
- Datos: Los 8 bytes de datos contienen la información real.
- CDN: La verificación de redundancia cíclica se utiliza para detectar errores.
- ACK: La ranura ACK indica si el nodo ha reconocido y recibido los datos correctamente.
- EOF: El EOF marca el final del marco CAN.
Lo especial del bus CAN es que se trata de un protocolo basado en mensajes. Normalmente, en una red distribuida, cada dispositivo tiene una ID única para distinguirlo de otros dispositivos en el mismo bus, y los mensajes se envían desde el Dispositivo A al Dispositivo B según sus ID.
Por el contrario, las estaciones del bus CAN no tienen ID. Más bien, a cada mensaje se le asigna una ID CAN única que indica de qué trata el mensaje. Todos los nodos reciben todos los mensajes y cada nodo filtra los mensajes relevantes para él.
Descripción general del hardware del módulo MCP2515
El módulo de interfaz de bus CAN MCP2515 es una solución CAN completa que incluye el controlador CAN MCP2515 de Microchip y el transceptor CAN de alta velocidad TJA1050 de Philips. Es la mejor solución para agregar conectividad CAN con interfaz SPI a su Arduino.
Debido a su confiabilidad y robustez, el módulo MCP2515 se puede utilizar en diversos proyectos que requieren una transmisión de datos confiable en ambientes ruidosos o en largas distancias.
El controlador CAN MCP2515
El MCP2515 es un controlador CAN independiente que implementa la especificación CAN versión 2.0B. Es capaz de enviar y recibir datos estándar y extendidos y tramas remotas. El MCP2515 incluye máscaras y filtros para filtrar mensajes no deseados, lo que reduce la sobrecarga de la MCU del host.
El MCP2515 tiene un pin de salida de interrupción (INT) que puede activar una interrupción de MCU cuando se recibe y carga un mensaje válido en uno de los búferes de recepción.
El transceptor CAN TJA1050
El TJA1050 sirve como interfaz entre un controlador CAN MCP2515 y el bus CAN físico de dos cables, cumpliendo con los requisitos automotrices de alta velocidad (hasta 1 Mbps), baja corriente de reposo, compatibilidad electromagnética y descarga electrostática.
Con el transceptor CAN TJA1050 se pueden conectar al bus un máximo de 110 estaciones.
Conexión de bus CAN
Hay un terminal de tornillo de 2 pines (etiquetado H y L) a bordo para conectar un cable de par trenzado de bus CAN.
El módulo MCP2515 admite velocidades de datos de hasta 1 Mbit/s. Sin embargo, la velocidad de transmisión máxima está determinada por la longitud de la línea de autobús: las líneas de autobús más largas conducen a velocidades de transmisión más lentas. La longitud máxima del bus es de 40 metros a 1 Mbit/s y puede alcanzar los 500 metros a 125 kbit/s.
Terminación de nodo
El bus CAN debe estar terminado con resistencias en ambos extremos para evitar reflexiones en la línea. Por lo tanto, el módulo MCP2515 tiene un terminador de 120 ohmios y un puente de terminación de nodo. Para activar la resistencia debes dejar el jumper en su lugar.
Si el módulo es el primer o último nodo de la red CAN, se debe configurar el puente. Si el módulo es un nodo central, se debe quitar el puente.
Especificaciones técnicas
Aquí están las especificaciones:
| Tensión de funcionamiento | 4,75 a 5,25 V (según los requisitos de TJA1050) |
| Especificación de lata | Versión 2.0B con 1 Mbit/s |
| Frecuencia de cristal | 8MHz |
| Búfer de transmisión | Tres buffers de envío con funciones de priorización y cancelación. |
| Recibir buffer | Dos buffers de recepción con almacenamiento de mensajes priorizados |
| Filtro de mensajes | Seis filtros de 29 bits |
| Máscaras | Dos máscaras de 29 bits |
| Salidas de interrupción | Una interrupción con habilitaciones seleccionables. |
| interfaz | SPI de alta velocidad (10MHz) |
Puede encontrar más información sobre el controlador CAN MCP2515 en la siguiente hoja de datos.
Para obtener más información sobre el transceptor CAN TJA1050, consulte la hoja de datos a continuación.
Configuración de pines del módulo MCP2515
Ahora veamos el pinout.
Puerto de entrada
Los pines de ruptura en un lado del módulo se utilizan para comunicarse con el microcontrolador.
EN T El pin genera una interrupción cuando se recibe y carga un mensaje válido en uno de los buffers de recepción.
SCK es el pin del reloj SPI.
SI es la entrada de datos en serie/pin MOSI para los datos enviados desde su Arduino al módulo.
ENTONCES es la salida de datos en serie/pin MISO para los datos enviados desde el módulo a su Arduino.
C.S. es el pin de selección de chip. Debe mantenerse bajo para iniciar una transacción SPI.
Tierra es una base común para el poder y la lógica.
VCC es el pin de alimentación. Conéctelo únicamente a una fuente de alimentación de 5 V.
Conexión de bus CAN
En el otro lado del módulo hay un terminal de tornillo de 2 pines y un cabezal de pines de 2 pines para conectar cables de par trenzado del bus CAN.
l es la señal CAN baja para el estándar de bus CAN.
h es la señal CAN alta para el estándar de bus CAN.
Conexión de hardware
Ahora que sabemos todo sobre el módulo, construyamos nuestra propia red CAN.
Ejemplo 1: red CAN simple con dos nodos
En este ejemplo, se configura una red de bus CAN simple con dos nodos: un nodo envía un mensaje y el otro lo recibe.
Primero, conecte el pin VCC del módulo a 5 V en el Arduino y el pin GND a tierra.
Conectemos los pines SPI. Tenga en cuenta que cada placa Arduino tiene un conjunto único de pines SPI que deben conectarse en consecuencia. En placas Arduino como UNO/Nano V3.0, estos pines son digitales 13 (SCK), 12 (MISO), 11 (MOSI) y 10 (CS). Si estás utilizando otra placa Arduino, lee la documentación oficial. Posiciones de los pines SPI Antes de continuar.
Ahora conecta el pin INT del módulo al pin digital 2 del Arduino.
Necesitas crear dos de esos circuitos. Uno actúa como transmisor y el otro como receptor. Ambos tienen el mismo cableado.
La conexión de los módulos es sencilla: CAN L está conectado a CAN L y CAN H está conectado a CAN H. Lo ideal es que los cables estén torcidos, pero esto no es necesario para pruebas simples de placas de pruebas u otras tiradas cortas.
Es importante recordar que a medida que aumenta la longitud del bus o aumenta el ruido eléctrico ambiental, el uso de cables de par trenzado y la adición de blindaje se vuelven más importantes.
Por último, coloca el jumper en ambos módulos ya que se trata de una red de bus CAN simple con dos nodos.
Construya la red como se muestra.
Ejemplo 2: red CAN de múltiples nodos
En este ejemplo, se configura una red CAN más grande: varios nodos envían mensajes y un nodo los reenvía a una PC a través de una interfaz en serie.
Se pueden agregar nodos adicionales entre los dos nodos finales. Estos se pueden empalmar en serie o conectar al bus principal con un cable de acometida corto, siempre que la longitud sea inferior a 12 pulgadas.
Finalmente, coloque el puente en el primer y último nodo de la red CAN y retírelo de los nodos intermedios.
Construya la red como se muestra.
Instalación de biblioteca
Hay una biblioteca realmente excelente disponible para trabajar con el módulo MCP2515. Debe descargarlo e instalarlo en su IDE de Arduino.
Para instalar la biblioteca, navegue hasta Bosquejo > incluir biblioteca > Administrar bibliotecas… Espere a que el administrador de la biblioteca descargue el índice de la biblioteca y actualice la lista de bibliotecas instaladas.
Filtra tu búsqueda escribiendo “mcp2515'. Buscar PUEDE de Mistry Sandeep. Haga clic en esta entrada y luego seleccione «Instalar».
código de ejemplo de arduino
En esta sencilla prueba intentaremos transmitir un mensaje «Hola mundo» en el bus CAN para ver si se puede decodificar. Le ayuda a aprender a utilizar los módulos y puede servir como base para futuros experimentos y proyectos prácticos.
Código para el nodo emisor
Cargue este boceto en el nodo remitente.
Si tiene varios nodos en un bus CAN, cargue este boceto en cada nodo transmisor. Asegúrese de cambiar los ID de mensaje de cada nodo a valores únicos.
#include <CAN.h>
void setup() {
Serial.begin(9600);
while (!Serial);
Serial.println("CAN Sender");
// start the CAN bus at 500 kbps
if (!CAN.begin(500E3)) {
Serial.println("Starting CAN failed!");
while (1);
}
}
void loop() {
// send packet: id is 11 bits, packet can contain up to 8 bytes of data
Serial.print("Sending packet ... ");
CAN.beginPacket(0x12);
CAN.write('h');
CAN.write('e');
CAN.write('l');
CAN.write('l');
CAN.write('o');
CAN.endPacket();
Serial.println("done");
delay(1000);
// send extended packet: id is 29 bits, packet can contain up to 8 bytes of data
Serial.print("Sending extended packet ... ");
CAN.beginExtendedPacket(0xabcdef);
CAN.write('w');
CAN.write('o');
CAN.write('r');
CAN.write('l');
CAN.write('d');
CAN.endPacket();
Serial.println("done");
delay(1000);
}Código para el nodo receptor
Cargue este boceto en el nodo destinatario.
#include <CAN.h>
void setup() {
Serial.begin(9600);
while (!Serial);
Serial.println("CAN Receiver Callback");
// start the CAN bus at 500 kbps
if (!CAN.begin(500E3)) {
Serial.println("Starting CAN failed!");
while (1);
}
// register the receive callback
CAN.onReceive(onReceive);
}
void loop() {
// do nothing
}
void onReceive(int packetSize) {
// received a packet
Serial.print("Received ");
if (CAN.packetExtended()) {
Serial.print("extended ");
}
if (CAN.packetRtr()) {
// Remote transmission request, packet contains no data
Serial.print("RTR ");
}
Serial.print("packet with id 0x");
Serial.print(CAN.packetId(), HEX);
if (CAN.packetRtr()) {
Serial.print(" and requested length ");
Serial.println(CAN.packetDlc());
} else {
Serial.print(" and length ");
Serial.println(packetSize);
// only print packet data for non-RTR packets
while (CAN.available()) {
Serial.print((char)CAN.read());
}
Serial.println();
}
Serial.println();
}Tenga en cuenta que la función de bucle se deja vacía porque el boceto utiliza una interrupción para notificar al Arduino cuando se recibe un mensaje válido y se carga en uno de los buffers de recepción.
demostración
Después de cargar el boceto, abra el monitor en serie con una velocidad de baudios de 9600. El nodo remitente envía un paquete CAN estándar y un paquete CAN extendido cada segundo.
El nodo receptor lo recibe y lo transmite al PC a través de la interfaz serie.
Introducción
En los viejos tiempos, los automóviles tenían más de 2,000 metros de cable en ellos, conectando interruptores en el tablero directamente con las luces delanteras y traseras, por ejemplo. A medida que los autos se volvieron más complejos, esta lógica simple ya no funcionaría. En 1986, Bosch introdujo el sistema CAN bus, que resolvió este problema y facilitó y abarató la fabricación de autos. CAN es ahora el estándar de la industria y se utiliza en todo, desde autos y camiones hasta autobuses y tractores, e incluso aviones y barcos.
Preguntas Frecuentes sobre la Creación de una red CAN con módulos MCP2515 y Arduino
-
¿Qué es un sistema CAN Bus?
Un Controller Area Network (CAN bus) es un estándar de comunicaciones diseñado para permitir que los dispositivos dentro de un vehículo se comuniquen entre sí sin necesidad de una computadora central.
-
¿Cómo funciona el sistema CAN Bus?
Similar al sistema nervioso humano, el CAN bus actúa como el sistema nervioso del automóvil, permitiendo la comunicación entre diferentes nodos del bus CAN, también conocidos como Unidades de Control Electrónico (ECUs).
-
¿Qué es un nodo CAN Bus?
Cada nodo CAN contiene un transceptor CAN, un controlador CAN y un microcontrolador que le permite enviar y recibir mensajes a través del bus CAN.
Descripción del Módulo MCP2515
El módulo de interfaz CAN MCP2515 es la mejor solución para agregar conectividad CAN a tu Arduino con interfaz SPI. Este tutorial te mostrará cómo conectar el módulo MCP2515 a un Arduino, pero primero, una breve introducción sobre el protocolo CAN.
Información Técnica
El MCP2515 es un controlador CAN autónomo que implementa la especificación CAN, Versión 2.0B. Es capaz de transmitir y recibir tramas de datos estándar y extendidas, e incluye máscaras y filtros para filtrar mensajes no deseados, lo que reduce la carga del microcontrolador host.
Por otro lado, el transceptor CAN TJA1050 actúa como una interfaz entre el controlador MCP2515 CAN y el bus físico CAN de dos cables, cumpliendo con los requisitos automotrices para alta velocidad, baja corriente en reposo, compatibilidad electromagnética y descarga electrostática.
Instalación de la Biblioteca y Ejemplos de Código para Arduino
Hay una excelente biblioteca disponible para trabajar con el módulo MCP2515. Deberás descargar e instalar esta biblioteca en tu Arduino IDE. Para hacerlo, navega a Sketch > Include Library > Manage Libraries… Busca la biblioteca ‘CAN’ de Sandeep Mistry y haz clic en Instalar.
Ejemplo de Código para el Nodo Transmisor
Aquí tienes un ejemplo de código que puedes cargar en el nodo transmisor para enviar un mensaje «Hola Mundo» a través de la red CAN:
#include <CAN.h>
void setup() {
Serial.begin(9600);
while (!Serial);
Serial.println("CAN Sender");
if (!CAN.begin(500E3)) {
Serial.println("¡Fallo al iniciar CAN!");
while (1);
}
}
void loop() {
Serial.print("Enviando paquete ... ");
CAN.beginPacket(0x12);
CAN.write('h');
CAN.write('e');
CAN.write('l');
CAN.write('l');
CAN.write('o');
CAN.endPacket();
Serial.println("hecho");
delay(1000);
}
Ejemplo de Código para el Nodo Receptor
Este sería un ejemplo de código para el nodo receptor:
#include <CAN.h>
void setup() {
Serial.begin(9600);
while (!Serial);
Serial.println("Receptor CAN");
if (!CAN.begin(500E3)) {
Serial.println("¡Fallo al iniciar CAN!");
while (1);
}
CAN.onReceive(onReceive);
}
void loop() {
}
void onReceive(int packetSize) {
Serial.print("Recibido ");
if (CAN.packetExtended()) {
Serial.print("extendido ");
}
if (CAN.packetRtr()) {
Serial.print("RTR ");
}
Serial.print("paquete con ID 0x");
Serial.print(CAN.packetId(), HEX);
if (CAN.packetRtr()) {
Serial.print(" y longitud solicitada ");
Serial.println(CAN.packetDlc());
} else {
Serial.print(" y longitud ");
Serial.println(packetSize);
while (CAN.available()) {
Serial.print((char)CAN.read());
}
Serial.println();
}
Serial.println();
}
Enlaces de Referencia:
Wow, ¡qué interesante descubrimiento! Definitivamente voy a intentar crear mi propia red CAN con estos módulos y mi Arduino. Gracias por compartir este artículo. ¡A experimentar se ha dicho! 🚀🤖
¡Qué chévere! Nunca pensé en utilizar esos módulos para crear una red CAN. Sin duda, me animaré a probarlo en mi Arduino. ¡Gracias por la info! 🚀🤖
¡No tenía idea de que se podía hacer eso con los módulos MCP2515 y Arduino! Definitivamente voy a experimentar con esto, ¡gracias por la inspiración!
¡Qué cool! Nunca imaginé que se pudiera hacer una red CAN con estos módulos. Definitivamente voy a intentarlo en mi Arduino, gracias por la información.
¡Qué interesante! Nunca pensé que se pudiera crear una red CAN con esos módulos, definitivamente voy a probarlo en mi Arduino. ¡Gracias por compartir!