Protocolo CAN - Sim, nós podemos !: 24 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Outro assunto recentemente sugerido pelos seguidores do meu canal no YouTube foi o protocolo CAN (Controller Area Network), que é o que vamos nos concentrar hoje. É importante explicar que CAN é um protocolo de comunicação serial simultânea. Isso significa que o sincronismo entre os módulos conectados à rede é realizado em relação ao início de cada mensagem enviada ao barramento. Começaremos apresentando os conceitos básicos do protocolo CAN e realizaremos uma montagem simples com dois ESP32s.

Em nosso circuito, os ESPs podem atuar como Master e Slave. Você pode ter vários microcontroladores transmitindo simultaneamente, porque o CAN lida com a colisão de tudo automaticamente. O código-fonte deste projeto é super simples. Confira!

Etapa 1: Recursos usados

• Dois módulos de ESP WROOM 32 NodeMcu
• Dois transceptores CAN do WaveShare
• Jumpers para conexões
• Analisador lógico para captura
• Três cabos USB para ESPs e analisador
• 10 metros de par trançado para servir de ônibus

Etapa 2: CAN (rede de área do controlador)

• Foi desenvolvido por Robert Bosch GmbH na década de 1980 para servir à indústria automotiva.
• Tornou-se generalizado ao longo dos anos devido à sua robustez e flexibilidade de implementação. Ele está sendo usado com equipamentos militares, máquinas agrícolas, automação industrial e predial, robótica e equipamentos médicos.

Etapa 3: CAN - Recursos

• Comunicação serial de dois fios
• Máximo de 8 bytes de informações úteis por quadro, com possível fragmentação
• Endereço direcionado para a mensagem e não para o nó
• Atribuição de prioridade a mensagens e retransmissão de mensagens "em espera"
• Capacidade efetiva de detectar e sinalizar erros
• Capacidade multimestre (todos os nós podem solicitar acesso ao barramento)
• Capacidade multicast (uma mensagem para vários receptores ao mesmo tempo)
• Taxas de transferência de até 1Mbit / s em um barramento de 40 metros (redução da taxa com o aumento do comprimento do barramento)
• Flexibilidade de configuração e introdução de novos nós (até 120 nós por barramento)
• Hardware padrão, baixo custo e boa disponibilidade
• Protocolo regulamentado: ISO 11898

Etapa 4: Circuito usado

Aqui, eu tenho os transceptores. Há um de cada lado e eles são conectados por um par de fios. Um é responsável pelo envio e o outro pelo recebimento dos dados.

Etapa 5: Tensões da linha de transmissão (detecção diferencial)

No CAN, o bit dominante é Zero.

A detecção de diferencial de linha reduz a sensibilidade ao ruído (EFI)

Etapa 6: Padrões CAN e formato de frames

Formato padrão com identificador de 11 bits

Etapa 7: Padrões CAN e formato de frames

Formato estendido com identificador de 29 bits

Etapa 8: Padrões CAN e formato de frames

É importante observar que um protocolo já calcula o CRC e envia sinais ACK e EOF, coisas que já são feitas pelo protocolo CAN. Isso garante que a mensagem enviada não chegue da maneira errada. Isso porque se der problema no CRC (Redundant Cyclic Check ou Redundancy Check), que é igual a um dígito de verificação da informação, ele será identificado pelo CRC.

Etapa 9: Quatro tipos de frames (frames)

É importante observar que um protocolo já calcula o CRC e envia sinais ACK e EOF, coisas que já são feitas pelo protocolo CAN. Isso garante que a mensagem enviada não chegue da maneira errada. Isso porque se der problema no CRC (Redundant Cyclic Check ou Redundancy Check), que é igual a um dígito de verificação da informação, ele será identificado pelo CRC.

Quatro tipos de frames (frames)

A transmissão e recepção de dados no CAN são baseadas em quatro tipos de frames. Os tipos de quadro serão identificados por variações nos bits de controle ou mesmo por mudanças nas regras de escrita de quadro para cada caso.

• Quadro de dados: Contém os dados do transmissor para o (s) receptor (es)
• Frame remoto: esta é uma solicitação de dados de um dos nós
• Frame de Erro: É um frame enviado por qualquer um dos nós ao identificar um erro no barramento e pode ser detectado por todos os nós
• Overload Frame: Serve para atrasar o tráfego no barramento devido à sobrecarga de dados ou atraso em um ou mais nós.

Etapa 10: Circuito - Detalhes das conexões

Etapa 11: Circuito - Captura de Dados

Comprimentos de onda obtidos para CAN padrão com ID de 11 bits

Etapa 12: Circuito - Captura de dados

Comprimentos de onda obtidos para CAN estendido com ID de 29 bits

Etapa 13: Circuito - Captura de dados

Dados obtidos pelo analisador lógico

Etapa 14: Biblioteca Arduino - CAN

Eu mostro aqui as duas opções onde você pode instalar a Biblioteca de Drivers CAN

Arduino IDE Library Manager

Etapa 15: Github

github.com/sandeepmistry/arduino-CAN

Etapa 16: Código-fonte do transmissor

Código Fonte: Inclui e Configuração ()

Incluiremos a biblioteca CAN, iniciaremos a série para depuração e iniciaremos o barramento CAN a 500 kbps.

#include // Inclui uma biblioteca CAN void setup () {Serial.begin (9600); // inicia um serial para debug while (! Serial); Serial.println ("Transmissor CAN"); // Inicia o barramento CAN a 500 kbps if (! CAN.begin (500E3)) {Serial.println ("Falha ao iniciar o controlador CAN"); // caso não seja possível iniciar o driver while (1); }}

Etapa 17: Código Fonte: Loop (), Enviando um Pacote CAN 2.0 Padrão

Utilizando o padrão CAN 2.0, enviamos um pacote. O ID de 11 bits identifica a mensagem. O bloco de dados deve ter até 8 bytes. Ele inicia o pacote com ID 18 em hexadecimal. Ele compacta 5 bytes e fecha a função.

void loop () {// Usando o CAN 2.0 padrão // Envia um pacote: o id tem 11 bits e identifica a mensagem (prioridade, evento) // 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."); atraso (1000);

Etapa 18: Código Fonte: Loop (), Enviando um Pacote CAN 2.0 Estendido

Nesta etapa, o ID possui 29 bits. Ele começa a enviar 24 bits de ID e, mais uma vez, compacta 5 bytes e sai.

// 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."); atraso (1000); }

Etapa 19: Código Fonte do Receptor

Código Fonte: Inclui e Configuração ()

Novamente, incluiremos a biblioteca CAN, iniciaremos a serial para depuração e iniciaremos o barramento CAN a 500 kbps. Se ocorrer um erro, esse erro será impresso.

#include // Inclui uma biblioteca CAN void setup () {Serial.begin (9600); // inicia um 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 não seja possível iniciar o driver while (1); }}

Etapa 20: Código-fonte: Loop (), obtendo o pacote e verificando o formato

Tentamos verificar o tamanho do pacote recebido. O método CAN.parsePacket () me mostra o tamanho desse pacote. Portanto, se tivermos um pacote, verificaremos se ele está estendido ou não.

void loop () {// Tenta verificar o tamanho do acote compactação 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"); }

Etapa 21: Fonte: Loop (), verifica se é um pacote remoto

Aqui, verificamos se o pacote recebido é uma solicitação de dados. Nesse caso, não há dados.

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

Etapa 22: Código Fonte: Loop (), Comprimento de Dados Solicitado ou Recebido

Se o pacote recebido for um pedido, indicamos o comprimento solicitado. Em seguida, obtemos o Código de Comprimento de Dados (DLC), que indica o comprimento dos dados. Por fim, indicamos o comprimento recebido.

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

Etapa 23: Código-fonte: Loop (), se os dados forem recebidos, ele será impresso

Imprimimos (no monitor serial) os dados, mas apenas se o pacote recebido não for um pedido.

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

Etapa 24: Baixe os arquivos

PDF

EU NÃO