No domínio das aplicações automotivas e industriais, a comunicação confiável entre vários microcontroladores é fundamental. O protocolo de barramento da rede de área do controlador (CAN) surgiu como uma solução robusta para essas necessidades. Esta postagem do blog investiga os fundamentos do protocolo CAN Bus e demonstra como integrar o controlador MCP2515 CAN com um Arduino, permitindo comunicação perfeita em seus projetos.
O que é o protocolo de barramento?
O barramento da rede da área do controlador (CAN) é um padrão de barramento de veículos robusto projetado para permitir que microcontroladores e dispositivos se comuniquem sem um computador host. Desenvolvido por Bosch na década de 1980, o BUS CAN se tornou um padrão em sistemas automotivos, mas também é amplamente utilizado na automação industrial e em outros sistemas incorporados.
Os principais recursos do protocolo de barramento CAN incluem:
- Configuração de vários mestres: Vários nós podem se comunicar no mesmo barramento sem um controlador central.
- Priorização da mensagem: As mensagens são priorizadas com base em seu identificador, garantindo que dados críticos sejam transmitidos primeiro.
- Detecção de erro: Mecanismos de detecção de erro robustos, incluindo verificações de CRC e bits de reconhecimento, aumentam a confiabilidade.
- Comunicação de alta velocidade: Suporta taxas de dados de até 1 Mbps, adequadas para aplicativos em tempo real.
Esses recursos tornam o ônibus pode ser ideal para cenários em que vários dispositivos precisam se comunicar de maneira eficiente e confiável, como em sistemas de gerenciamento de motores de veículos, automação industrial e robótica.
Apresentando o MCP2515 CAN Controller
O MCP2515 é um controlador de rede de controladores independentes (CAN) que interfina os microcontroladores por meio da interface periférica serial (SPI). Ele lida com o intrincado pode protocolo, permitindo que os desenvolvedores se concentrem na lógica de aplicativo de nível superior. Os principais recursos do MCP2515 incluem:
- Suporte para quadros de lata padrão e estendido.
- Mecanismos de manuseio e filtragem de erros internos.
- Compatibilidade com vários microcontroladores, incluindo Arduino.
- Baixo consumo de energia, tornando -o adequado para sistemas incorporados.
Ao integrar o MCP2515 com um Arduino, você pode adicionar recursos de barramento CAN aos seus projetos, permitindo a comunicação com outros dispositivos ou redes habilitados para latas.
Configurando o MCP2515 com Arduino
Para começar, você precisará dos seguintes componentes:
- Conselho Arduino (por exemplo, Arduino Uno)
- MCP2515 CAN Módulo (geralmente vem com um transceptor TJA1050)
- Fios de jumper
- Breadboard (opcional)
Aqui está um guia passo a passo para configurar o MCP2515 com seu Arduino:
1. Fiação do MCP2515 para Arduino
Conecte o módulo MCP2515 ao Arduino da seguinte forma:
- VCC para 5V em Arduino
- Gnd para Gnd em Arduino
- Cs para Pino 10 em Arduino
- Sck para Pino 13 em Arduino
- SI (Mosi) para Pino 11 em Arduino
- ENTÃO (Miso) para Pino 12 em Arduino
- Int para Pino 2 em Arduino
Arduino MCP2515
------- -------
5V ------> VCC
GND ------> GND
Pin 10 ------> CS
Pin 13 ------> SCK
Pin 11 ------> SI (MOSI)
Pin 12 ------> SO (MISO)
Pin 2 ------> INT
2. Instalando as bibliotecas necessárias
Para se comunicar com o MCP2515, você precisará do MCP_CAN biblioteca. Instale -o através do Arduino Library Manager:
- Abra o Arduino IDE.
- Navegar para Esboço> Incluir biblioteca> Gerenciar bibliotecas ...
- Procurar MCP_CAN e instale o MCP_CAN Biblioteca de Cory J. Fowler.
3. Carregar o código de exemplo
Aqui está um exemplo básico para enviar e receber mensagens de lata usando o MCP2515 e o Arduino:
Enviando uma mensagem de lata
// Include the necessary libraries
#include
#include "mcp_can.h"
// Define the CS pin
#define CAN0_CS 10
// Initialize the CAN controller
MCP_CAN CAN0(CAN0_CS);
void setup() {
Serial.begin(115200);
while (CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ) != CAN_OK) {
Serial.println("CAN BUS Shield init fail");
Serial.println(" Init CAN BUS Shield again");
delay(100);
}
Serial.println("CAN BUS Shield init ok!");
CAN0.setMode(MCP_NORMAL);
}
void loop() {
byte data[] = {0x00, 0xFF, 0xAA, 0x55, 0x33, 0x66, 0x99, 0xCC};
// Send data: CAN ID = 0x100, data length = 8
if (CAN0.sendMsgBuf(0x100, 0, 8, data) == CAN_OK) {
Serial.println("Message Sent Successfully!");
} else {
Serial.println("Error Sending Message...");
}
delay(1000);
}
Recebendo uma mensagem de lata
// Include the necessary libraries
#include
#include "mcp_can.h"
// Define the CS pin
#define CAN0_CS 10
// Initialize the CAN controller
MCP_CAN CAN0(CAN0_CS);
void setup() {
Serial.begin(115200);
while (CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ) != CAN_OK) {
Serial.println("CAN BUS Shield init fail");
Serial.println(" Init CAN BUS Shield again");
delay(100);
}
Serial.println("CAN BUS Shield init ok!");
CAN0.setMode(MCP_NORMAL);
}
void loop() {
unsigned long canId;
byte len = 0;
byte buf[8];
// Check if data has been received
if (CAN0.checkReceive() == CAN_MSGAVAIL) {
CAN0.readMsgBuf(&canId, &len, buf);
Serial.print("CAN ID: 0x");
Serial.println(canId, HEX);
Serial.print("Data: ");
for (int i = 0; i < len; i++) {
Serial.print(buf[i], HEX);
Serial.print(" ");
}
Serial.println();
}
}
No esboço de envio, o Arduino transmite uma mensagem de lata com id 0x100 a cada segundo. O esboço de recebimento ouve mensagens de entrada e imprime o ID e os dados para o monitor serial.
Aplicações do ônibus CAN com Arduino
A integração do barramento CAN com o Arduino abre uma infinidade de aplicações além dos sistemas automotivos. Alguns casos de uso popular incluem:
- Robótica: Habilite a comunicação entre vários controladores de motor e sensores.
- Automação industrial: Facilitar a troca de dados entre diferentes máquinas e unidades de controle.
- Automação residencial: Conecte vários dispositivos inteligentes dentro de uma rede unificada.
- Sistemas de aquisição de dados: Colete e processe dados de vários sensores com eficiência.
Conclusão
O protocolo CAN BUS, com sua confiabilidade e eficiência, serve como uma espinha dorsal para a comunicação em vários sistemas incorporados. Ao utilizar o controlador CAN MCP2515 com um Arduino, os desenvolvedores podem integrar sem esforço os recursos de busca do CAN em seus projetos. Esteja você trabalhando em sistemas automotivos, automação industrial ou robótica complexa, a compreensão e a alavancagem podem o barramento pode melhorar significativamente a estrutura de comunicação do seu sistema.
Com os guias e exemplos abrangentes fornecidos, você está bem equipado para embarcar em integrar o ônibus CAN no seu próximo projeto Arduino. Codificação feliz!
