Como construir um barramento CAN com uma placa de ensaio e Arduino

O barramento Controller Area Network (CAN) é um protocolo de comunicação robusto e confiável amplamente utilizado em várias aplicações industriais, automotivas e aeroespaciais. Ele é projetado para a transmissão de dados entre microcontroladores e dispositivos através de uma rede de barramento CAN. Você pode não saber disso ainda, mas é a coisa por trás daqueles mods de painel de carro malucos que você vê nas redes sociais.

Orientaremos você sobre como construir um barramento CAN com o módulo CAN MCP2515 usando um Arduino e uma placa de ensaio. Também examinaremos a biblioteca CAN do Arduino e demonstraremos como enviar e receber dados pelo barramento CAN.

O que é um barramento CAN?

O barramento CAN é um protocolo de comunicação serial desenvolvido pela Bosch na década de 1980. É amplamente utilizado em diversas aplicações devido à sua alta confiabilidade e robustez. Ele permite a transmissão de dados entre dispositivos em altas velocidades com latência mínima em apenas duas linhas: CAN High e CAN Low.

Em 1994, o barramento CAN tornou-se um padrão internacional (ISO 11898) projetado especificamente para troca rápida de dados seriais entre controladores eletrônicos em aplicações automotivas. Confira nosso guia completo sobre o que é um barramento CAN e qual o papel que desempenha em sistemas automotivos para mais detalhes.

Uma das razões pelas quais o barramento CAN é tão popular é por causa de seus recursos de detecção e correção de erros. O protocolo pode detectar e corrigir erros na transmissão de dados. Isso o torna ideal para aplicações em que a integridade dos dados é crítica, como na automação industrial.

Conhecendo o Módulo CAN MCP2515

O módulo controlador de barramento CAN MCP2515 é um dispositivo que fornece suporte excepcional para o amplamente utilizado protocolo CAN versão 2.0B. Este módulo é ideal para comunicação em altas taxas de dados de até 1 Mbps.

O IC MCP2515 é um controlador CAN independente com uma interface SPI que permite a comunicação com uma ampla gama de microcontroladores. O IC TJA1050, por outro lado, funciona como uma interface entre o IC do controlador CAN MCP2515 e o barramento CAN físico.

Para maior conveniência, há um jumper que permite conectar a terminação de 120 ohm, tornando ainda mais fácil conectar seus fios ao CAN_H & EU POSSO parafusos para comunicação com outros módulos CAN.

Você pode obter informações adicionais no folha de dados MCP2515 caso você precise deste módulo para um projeto mais avançado.

Estrutura da Mensagem CAN

A estrutura da mensagem CAN consiste em vários segmentos, mas os segmentos mais críticos para este projeto são o identificador e os dados. O identificador, também conhecido como CAN ID ou Parameter Group Number (PGN), identifica os dispositivos no CAN rede, e o comprimento do identificador pode ser de 11 ou 29 bits, dependendo do tipo de protocolo CAN usado.

Enquanto isso, os dados representam os dados reais do sensor/controle que estão sendo transmitidos. Os dados podem ter de 0 a 8 bytes de comprimento, e o Data Length Code (DLC) indica o número de bytes de dados presentes.

A biblioteca de barramento CAN do Arduino MCP2515

Esta biblioteca implementa o Protocolo CAN V2.0B, que pode operar em velocidades de até 1 Mbps. Ele fornece uma interface SPI que pode operar em velocidades de até 10MHz enquanto oferece suporte a dados padrão (11 bits) e estendidos (29 bits). Além disso, ele vem com dois buffers de recebimento, que permitem o armazenamento prioritário de mensagens.

Inicializando o barramento CAN

Aqui está o código de configuração que você precisará para inicializar o barramento CAN:

#incluir
#incluir
MCP2515 mcp2515(10); // Define o pino CS
vazioconfigurar(){
enquanto (!Serial);
Serial.começar(9600);
SPI.começar(); //Inicia a comunicação SPI
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}

Isso inicializa o MCP2515 com uma taxa de bits CAN de 500 Kbps e uma frequência do oscilador de 8 MHz.

Modos operacionais CAN MCP2515

Existem três modos operacionais usados ​​com o controlador de barramento CAN MCP2515:

• setNormalMode(): define o controlador para enviar e receber mensagens.
• setLoopbackMode(): define o controlador para enviar e receber mensagens, mas as mensagens enviadas também serão recebidas por ele.
• setListenOnlyMode(): define o controlador para receber apenas mensagens.

Estas são chamadas de função usadas para definir o modo operacional do controlador de barramento CAN MCP2515.

mcp2515.setNormalMode();

mcp2515.setLoopbackMode();

mcp2515.setListenOnlyMode();

Enviando dados pelo barramento CAN

Para enviar uma mensagem pelo barramento CAN, use o enviarMsgBuf() método:

não assinadoCaracteres dados[] = {0x01, 0x02, 0x03, 0x04};
CAN.sendMsgBuf(0x01, 0, 4, dados);

Isso envia uma mensagem com o ID 0x01 e uma carga de dados de {0x01, 0x02, 0x03, 0x04}. O primeiro parâmetro é o CAN ID, o segundo é a prioridade da mensagem, o terceiro é o comprimento da carga de dados e o quarto é a própria carga de dados.

O enviarMsgBuf() O método retorna um valor indicando se a mensagem foi enviada com sucesso ou não. Você pode verificar esse valor chamando o verificarErro() método:

se (CAN.checkError()) {
Serial.println("Erro ao enviar mensagem.");
}

Isso verifica se ocorreu um erro durante a transmissão da mensagem e imprime uma mensagem de erro, se necessário.

Recebendo dados do barramento CAN

Para receber uma mensagem pelo barramento CAN, você pode usar o readMsgBuf() método:

não assinadoCaracteres len = 0;
não assinadoCaracteres buf[8];
não assinadoCaracteres canID = 0;
se (CAN.checkReceive()) {
 CAN.readMsgBuf(&len, buf);
 canID = CAN.getCanId();
}

Isso verifica se uma mensagem está disponível no barramento CAN e, em seguida, lê a mensagem no buf variedade. O comprimento da mensagem é armazenado no len variável, e o ID da mensagem é armazenado no canID variável.

Depois de receber uma mensagem, você pode processar a carga útil de dados conforme necessário. Por exemplo, você pode imprimir a carga de dados no monitor serial:

Serial.imprimir("Mensagem recebida com ID");
Serial.imprimir(canID, HEX);
Serial.imprimir(" e dados: ");
para (int eu = 0; i < len; i++) {
Serial.imprimir(buf[i], HEX);
Serial.imprimir(" ");
}
Serial.println();

Isso imprime o ID da mensagem recebida e a carga de dados para o monitor serial.

Como conectar um transceptor de barramento CAN a uma placa de ensaio

Para construir um barramento CAN para conectar dois dispositivos neste projeto de exemplo, você precisará de:

• Dois microcontroladores (duas placas Arduino Nano para este exemplo)
• Dois módulos CAN MCP2515
• uma tábua de pão
• Fios de jumper
• Um módulo de tela LCD I2C 16x2
• Sensor ultrassônico HC-SR04

Para este exemplo de projeto, quatro bibliotecas são usadas no esboço do Arduino. tem o NovoPing biblioteca, que fornece uma interface fácil de usar para o sensor ultrassônico, bem como o biblioteca SPI, que facilita a comunicação entre a placa Arduino e o controlador de barramento CAN MCP2515. O LiquidCrystal_I2C biblioteca é usada para o módulo de exibição.

Por último, há o biblioteca mcp2515 para fazer interface com o chip MCP2515, permitindo-nos transmitir dados facilmente pela rede de barramento CAN.

Configuração de Hardware (Exemplo HC-SR04)

Neste projeto utilizando um sensor HC-SR04 e LCD, uma placa Arduino Nano atuará como receptor, enquanto a outra Arduino atuará como remetente. Conecte os componentes do emissor de acordo com o diagrama de fiação abaixo:

Aqui está o diagrama para o circuito do receptor:

Por fim, conecte os dois nós usando o CAN_H e EU POSSO linhas como mostrado:

Ao conectar os módulos, é importante garantir que a tensão de alimentação esteja dentro da faixa especificada e que o CAN H e EU POSSO pinos estão conectados corretamente ao barramento.

Programação do módulo de barramento CAN MCP2515

Observe que ao programar o módulo MCP2515, é importante usar a taxa de bits correta para garantir uma comunicação bem-sucedida com outros dispositivos CAN na rede.

Código do remetente:

#incluir
#incluir
#incluir
MCP2515 mcp2515(10);
constbyte trigPin = 3;
constbyte echoPin = 4;
NovoPing sonar(trigPin, echoPin, 200);
estruturacan_framecanMsg;
vazioconfigurar(){
Serial.começar(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}
vaziolaço(){
não assinadoint distância = sonar.ping_cm();
 canMsg.can_id = 0x036; // ID da CAN como 0x036
 canMsg.can_dlc = 8; // Comprimento dos dados CAN como 8
 canMsg.data[0] = distância; //Atualiza valor de umidade em [0]
 canMsg.data[1] = 0x00; // Descansa tudo com 0 
 canMsg.data[2] = 0x00;
 canMsg.data[3] = 0x00;
 canMsg.data[4] = 0x00;
 canMsg.data[5] = 0x00;
 canMsg.data[6] = 0x00;
 canMsg.data[7] = 0x00;
 mcp2515.sendMessage(&canMsg);//Envia a mensagem CAN
atraso(100);
}

Código do receptor:

#incluir
#incluir
#incluir
MCP2515 mcp2515(10);
LiquidCrystal_I2C lcd(0x27,16,2);
estruturacan_framecanMsg;
vazioconfigurar(){
Serial.começar(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
 lcd.init();
 lcd.backlight();
 lcd.setCursor(0, 0);
 lcd.imprimir("MUO CAN TUTORIAL");
atraso(3000);
 lcd.claro();
}
vaziolaço(){
se (mcp2515.Leia a mensagem(&canMsg) == MCP2515::ERROR_OK) // Para receber dados
 {
int distância = canMsg.data[0];
 lcd.setCursor(0,0);
 lcd.imprimir("Distância: ");
 lcd.imprimir(distância);
 lcd.imprimir("cm ");
 }
}

Leve seus projetos Arduino para o próximo nível

A combinação do barramento CAN e do Arduino fornece uma plataforma poderosa para construir ou aprender redes de comunicação sofisticadas usadas em várias aplicações. Embora possa parecer uma curva de aprendizado íngreme, ter sua própria configuração em uma breadboard é uma maneira bastante útil de aprender como usar uma rede de barramento CAN em projetos DIY complexos.