Protocolo CAN - ¡Sí, podemos !: 24 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Otro tema sugerido recientemente por los seguidores de mi canal de YouTube fue el protocolo CAN (Controller Area Network), que es en lo que nos centraremos hoy. Es importante explicar que CAN es un protocolo de comunicación en serie simultáneo. Esto significa que el sincronismo entre los módulos conectados a la red se realiza en relación al inicio de cada mensaje enviado al bus. Comenzaremos presentando los conceptos básicos del protocolo CAN y realizaremos un ensamblaje simple con dos ESP32.

En nuestro circuito, los ESP pueden actuar tanto como Maestro como como Esclavo. Puede tener varios microcontroladores transmitiendo simultáneamente, porque la CAN se ocupa de la colisión de todo automáticamente. El código fuente de este proyecto es super simple. ¡Echale un vistazo!

Paso 1: Recursos utilizados

• Dos módulos de ESP WROOM 32 NodeMcu
• Dos transceptores CAN de WaveShare
• Jumpers para conexiones
• Analizador lógico para captura
• Tres cables USB para ESP y analizador
• 10 metros de par trenzado para servir de autobús

Paso 2: CAN (red de área del controlador)

• Fue desarrollado por Robert Bosch GmbH en la década de 1980 para servir a la industria automotriz.
• Se ha generalizado a lo largo de los años debido a su solidez y flexibilidad de implementación. Se está utilizando con equipos militares, maquinaria agrícola, automatización industrial y de edificios, robótica y equipos médicos.

Paso 3: CAN - Funciones

• Comunicación en serie de dos hilos
• Máximo de 8 bytes de información útil por trama, con posible fragmentación
• Dirección dirigida al mensaje y no al nodo
• Asignar prioridad a los mensajes y retransmitir mensajes "en espera"
• Capacidad efectiva para detectar y señalar errores.
• Capacidad multimaestro (todos los nodos pueden solicitar acceso al bus)
• Capacidad de multidifusión (un mensaje para varios receptores al mismo tiempo)
• Tasas de transferencia de hasta 1 Mbit / s en un bus de 40 metros (reducción de la tasa con aumento de la longitud de la barra)
• Flexibilidad de configuración e introducción de nuevos nodos (hasta 120 nodos por bus)
• Hardware estándar, bajo costo y buena disponibilidad
• Protocolo regulado: ISO 11898

Paso 4: circuito utilizado

Aquí tengo los transceptores. Hay uno a cada lado y están conectados por un par de cables. Uno es responsable de enviar y el otro de recibir datos.

Paso 5: Voltajes de la línea de transmisión (detección diferencial)

En CAN, el bit dominante es cero.

La detección diferencial de línea reduce la sensibilidad al ruido (EFI)

Paso 6: Formato de marcos y estándares CAN

Formato estándar con identificador de 11 bits

Paso 7: Formato de marcos y estándares CAN

Formato extendido con identificador de 29 bits

Paso 8: Formato de marcos y estándares CAN

Es importante notar que un protocolo ya calcula el CRC y envía señales ACK y EOF, que son cosas que ya hace el protocolo CAN. Esto garantiza que el mensaje enviado no llegará de forma incorrecta. Esto se debe a que si da un problema en el CRC (verificación cíclica redundante o verificación de redundancia), que es lo mismo que un dígito de verificación de información, será identificado por el CRC.

Paso 9: Cuatro tipos de marcos (marcos)

Es importante notar que un protocolo ya calcula el CRC y envía señales ACK y EOF, que son cosas que ya hace el protocolo CAN. Esto garantiza que el mensaje enviado no llegará de forma incorrecta. Esto se debe a que si da un problema en el CRC (verificación cíclica redundante o verificación de redundancia), que es lo mismo que un dígito de verificación de información, será identificado por el CRC.

Cuatro tipos de marcos (marcos)

La transmisión y recepción de datos en la CAN se basan en cuatro tipos de tramas. Los tipos de tramas se identificarán por variaciones en los bits de control o incluso por cambios en las reglas de escritura de tramas para cada caso.

• Marco de datos: contiene los datos del transmisor para el (los) receptor (es)
• Marco remoto: esta es una solicitud de datos de uno de los nodos
• Error Frame: Es un frame enviado por cualquiera de los nodos al identificar un error en el bus y puede ser detectado por todos los nodos.
• Trama de sobrecarga: sirve para retrasar el tráfico en el bus debido a una sobrecarga de datos o un retraso en uno o más nodos.

Paso 10: Circuito - Detalles de las conexiones

Paso 11: Circuito - Captura de datos

Longitudes de onda obtenidas para CAN estándar con ID de 11 bits

Paso 12: Circuito - Captura de datos

Longitudes de onda obtenidas para CAN extendido con ID de 29 bits

Paso 13: Circuito - Captura de datos

Datos obtenidos por el analizador lógico

Paso 14: Biblioteca Arduino - CAN

Aquí muestro las dos opciones donde puede instalar la biblioteca de controladores CAN

Administrador de bibliotecas IDE de Arduino

Paso 15: Github

github.com/sandeepmistry/arduino-CAN

Paso 16: Código fuente del transmisor

Código fuente: incluye y configuración ()

Incluiremos la biblioteca CAN, iniciaremos la serie para depurar e iniciaremos el bus CAN a 500 kbps.

#include // Inclui una biblioteca CAN void setup () {Serial.begin (9600); // inicia un serial para debug while (! Serial); Serial.println ("Transmisor CAN"); // Inicia o barramento CAN a 500 kbps if (! CAN.begin (500E3)) {Serial.println ("Falha ao iniciar o controlador CAN"); // caso no seja posible iniciar o controlador while (1); }}

Paso 17: Código fuente: Bucle (), envío de un paquete CAN 2.0 estándar

Usando el CAN 2.0 estándar, enviamos un paquete. El ID de 11 bits identifica el mensaje. El bloque de datos debe tener hasta 8 bytes. Inicia el paquete con ID 18 en hexadecimal. Empaqueta 5 bytes y cierra la función.

void loop () {// Usando o CAN 2.0 padrão // Envia um pacote: o id tem 11 bits e identifica a mensagem (prioridade, event) // o bloco de dados deve possuir até 8 bytes Serial.println ("Enviando pacote … "); CAN.beginPacket (0x12); // id 18 em hexadecimal CAN.write ('h'); // 1º byte CAN.write ('e'); // 2º byte CAN.write ('l'); // 3º byte CAN.write ('l'); // 4º byte CAN.write ('o'); // 5º byte CAN.endPacket (); // encerra o pacote para envio Serial.println ("Enviado."); retraso (1000);

Paso 18: Código fuente: Loop (), envío de un paquete CAN 2.0 extendido

En este paso, el ID tiene 29 bits. Comienza a enviar 24 bits de ID y, una vez más, empaqueta 5 bytes y se cierra.

// Usando CAN 2.0 Estendido // Envia um pacote: o id tem 29 bits e identifica a mensagem (prioridade, evento) // o bloco de dados deve possuir até 8 bytes Serial.println ("Enviando pacote estendido…"); CAN.beginExtendedPacket (0xabcdef); // id 11259375 decimal (abcdef em hexa) = 24 bits preenchidos até aqui CAN.write ('w'); // 1º byte CAN.write ('o'); // 2º byte CAN.write ('r'); // 3º byte CAN.write ('l'); // 4º byte CAN.write ('d'); // 5º byte CAN.endPacket (); // encerra o pacote para envio Serial.println ("Enviado."); retraso (1000); }

Paso 19: Código fuente del receptor

Código fuente: incluye y configuración ()

Nuevamente, incluiremos la biblioteca CAN, iniciaremos la serie para depurar e iniciaremos el bus CAN a 500 kbps. Si ocurre un error, este error se imprimirá.

#include // Inclui una biblioteca CAN void setup () {Serial.begin (9600); // inicia un serial para debug while (! Serial); Serial.println ("Receptor CAN"); // Inicia o barramento CAN a 500 kbps if (! CAN.begin (500E3)) {Serial.println ("Falha ao iniciar o controlador CAN"); // caso no seja posible iniciar o controlador while (1); }}

Paso 20: Código fuente: bucle (), obtención del paquete y verificación del formato

Intentamos comprobar el tamaño del paquete recibido. El método CAN.parsePacket () me muestra el tamaño de este paquete. Entonces, si tenemos un paquete, verificaremos si está extendido o no.

void loop () {// Tenta verificar o tamanho hacer acote recebido int packetSize = CAN.parsePacket (); if (packetSize) {// Se temos um pacote Serial.println ("Recebido pacote."); if (CAN.packetExtended ()) {// verifica se o pacote é estendido Serial.println ("Estendido"); }

Paso 21: Fuente: Loop (), verifica si es un paquete remoto

Aquí, verificamos si el paquete recibido es una solicitud de datos. En este caso, no hay datos.

if (CAN.packetRtr ()) {// Verifica se o pacote é um pacote remoto (Requisição de dados), neste caso não há dados Serial.print ("RTR"); }

Paso 22: Código fuente: bucle (), longitud de datos solicitada o recibida

Si el paquete recibido es una solicitud, indicamos la longitud solicitada. Luego obtenemos el Código de longitud de datos (DLC), que indica la longitud de los datos. Finalmente, indicamos la longitud recibida.

Serial.print ("Pacote com id 0x"); Serial.print (CAN.packetId (), HEX); if (CAN.packetRtr ()) {// se o pacote recebido é de requisição, indicamos o comprimento solicitado Serial.print ("e requsitou o comprimento"); Serial.println (CAN.packetDlc ()); // obtem o DLC (Código de longitud de datos, que indica o comprimento dos dados)} else {Serial.print ("e comprimento"); // aqui somente indica o comprimento recebido Serial.println (packetSize);

Paso 23: Código fuente: bucle (), si se reciben datos, se imprimen

Imprimimos (en el monitor serial) los datos, pero solo si el paquete recibido no es una solicitud.

// Imprime os dados somente se o pacote recebido não foi de requisição while (CAN.available ()) {Serial.print ((char) CAN.read ()); } Serial.println (); } Serial.println (); }}

Paso 24: Descarga los archivos

PDF

INO