Arduino pode criar um tutorial

Hoje, qualquer carro médio consiste em cerca de 60 a 100 unidades de sensores para detecção e troca de informações. Com os fabricantes de carros fazendo constantemente seus carros mais inteligentes com recursos como direção autônoma, sistema de airbag, monitoramento da pressão dos pneus, sistema de controle de cruzeiro, etc., esse número só deve aumentar. Ao contrário de outros sensores, esses sensores processam informações críticas e, portanto, os dados desses sensores devem ser comunicados usando protocolos de comunicação automotiva padrão. Por exemplo, dados do sistema de controle de cruzeiro, como velocidade, posição do acelerador, etc., são valores vitais que são enviados para a Unidade de Controle Eletrônico (ECU)para decidir o nível de aceleração do carro, uma falha de comunicação ou perda de dados aqui pode levar a falhas críticas. Portanto, ao contrário dos protocolos de comunicação padrão como UART, SPI ou I2C, os designers usam protocolos de comunicação automotiva muito confiáveis, como LIN, CAN, FlexRay, etc.

De todos os protocolos disponíveis, o CAN é o mais predominantemente usado e popular. Já discutimos o que é CAN e como funciona o CAN. Portanto, neste artigo, examinaremos o básico novamente e, finalmente, também trocaremos dados entre dois Arduinos usando comunicação CAN. Parece interessante, certo! Então vamos começar.

Introdução ao CAN

CAN, também conhecido como Controller Area Network, é um barramento de comunicação serial projetado para aplicações industriais e automotivas. É um protocolo baseado em mensagem usado para comunicação entre vários dispositivos. Quando vários dispositivos CAN são conectados juntos como mostrado abaixo, a conexão forma uma rede agindo como nosso sistema nervoso central, permitindo que qualquer dispositivo fale com qualquer outro dispositivo no nó.

Uma rede CAN consistirá em apenas dois fios CAN alto e CAN baixo para transmissão de dados bidirecional, conforme mostrado acima. Normalmente, a velocidade de comunicação para CAN varia de 50 Kbps a 1Mbps e a distância pode variar de 40 metros a 1Mbps a 1000 metros a 50kpbs.

Formato da mensagem CAN:

Na comunicação CAN, os dados são transmitidos na rede como um formato de mensagem particular. Este formato de mensagem contém vários segmentos, mas dois segmentos principais são o identificador e os dados que ajudam a enviar e responder a mensagens no barramento CAN.

Identificador ou CAN ID: O identificador também é conhecido como CAN ID ou PGN (Número do Grupo de Parâmetros). É usado para identificar os dispositivos CAN presentes em uma rede CAN. O comprimento do identificador é de 11 ou 29 bits com base no tipo de protocolo CAN usado.

CAN padrão: 0-2047 (11 bits)

CAN estendido: 0-2 ²⁹ -1 (29 bits)

Dados: são os dados reais do sensor / controle que devem ser enviados de um dispositivo para outro. Os dados de tamanho podem ter de 0 a 8 bytes de comprimento.

Código de comprimento de dados (DLC): 0 a 8 para o número de bytes de dados presentes.

Fios usados em CAN:

O protocolo CAN consiste em dois fios, nomeadamente CAN_H e CAN_L, para enviar e receber informações. Ambos os fios atuam como uma linha diferencial, ou seja, o sinal CAN (0 ou 1) é representado pela diferença de potencial entre CAN_L e CAN_H. Se a diferença for positiva e maior do que uma certa tensão mínima, então será 1 e se a diferença for negativa será 0.

Normalmente, um cabo de par trançado é usado para comunicação CAN. Um único resistor de 120 ohms é geralmente usado nas duas extremidades da rede CAN, conforme mostrado na imagem, porque a linha precisa ser balanceada e ligada ao mesmo potencial.

Comparação de CAN sobre SPI e I2C

Como já aprendemos como usar SPI com Arduino e IIC com Arduino, vamos comparar os recursos de SPI e I2C com CAN

Parâmetro	SPI	I2C	POSSO
Rapidez	3 Mbps a 10 Mbps	Padrão: 100Kbps	10 KBps a 1 MBps também depende do comprimento do fio usado
Rápido: 400 Kbps
Alta velocidade: 3,4 Mbps
Tipo	Síncrono	Síncrono	Assíncrono
Número de Fios	3+ (MISO, MOSI, SCK, SS1, SS2… SS (n))	2 fios (SDA, SCL)	2 fios (CAN_H, CAN_L)
Duplex	Full Duplex	Meio duplex	Meio duplex

Aplicativos de protocolo CAN

Por causa da robustez e confiabilidade do protocolo CAN, eles são usados em indústrias como automotiva, máquinas industriais, agricultura, equipamentos médicos, etc.
Como a complexidade da fiação é reduzida no CAN, eles são usados principalmente em aplicações automotivas, como automóveis.
Baixo custo de implementação e preço dos componentes de hardware também é menor.
Fácil de adicionar e remover os dispositivos de barramento CAN.

Como usar o protocolo CAN no Arduino

Como o Arduino não contém nenhuma porta CAN embutida, um módulo CAN chamado MCP2515 é usado. Este módulo CAN faz interface com o Arduino usando a comunicação SPI. Vamos ver mais sobre o MCP2515 em detalhes e como ele faz interface com o Arduino.

Módulo CAN MCP2515:

O módulo MCP2515 possui um controlador CAN MCP2515 que é um transceptor CAN de alta velocidade. A conexão entre MCP2515 e MCU é através de SPI. Portanto, é fácil fazer interface com qualquer microcontrolador com interface SPI.

Para iniciantes que desejam aprender o CAN Bus, este módulo funcionará como um bom começo. Esta placa CAN SPI é ideal para automação industrial, automação residencial e outros projetos automotivos embarcados.

Recursos e especificações de MCP2515:

Usa o transceptor CAN de alta velocidade TJA1050
Dimensão: 40 × 28 mm
Controle SPI para expandir a interface de barramento Multi CAN
Oscilador de cristal 8MHZ
Resistência terminal 120Ω
Possui chave independente, indicador LED, indicador de energia
Suporta operação CAN de 1 Mb / s
Operação de espera de baixa corrente
Até 112 nós podem ser conectados

Pinagem do Módulo CAN MCP2515:

Nome do Pin	USAR
VCC	Pino de entrada de energia 5V
GND	Pino de aterramento
CS	PIN de seleção SPI SLAVE (baixo ativo)
ENTÃO	SPI master input slave output lead
SI	Terminal de entrada escravo de saída mestre SPI
SCLK	PIN do relógio SPI
INT	Pino de interrupção MCP2515

Neste tutorial, vamos ver como enviar dados do sensor de umidade e temperatura (DHT11) do Arduino Nano para o Arduino Uno via módulo de barramento CAN MCP2515.

Componentes necessários

Arduino UNO
Arduino NANO
DHT11
Display LCD 16x2
Módulo CAN MCP2515 - 2
Potenciômetro de 10k
Tábua de pão
Fios de conexão

Diagrama de circuito

Conexão no lado do transmissor CAN:

Componente - Pin	Arduino Nano
MPC2515 - VCC	+ 5V
MPC2515 - GND	GND
MPC2515 - CS	D10 (SPI_SS)
MPC2515 - SO	D12 (SPI_MISO)
MPC2515 - SI	D11 (SPI_MOSI)
MPC2515 - SCK	D13 (SPI_SCK)
MPC2515 - INT	D2
DHT11 - VCC	+ 5V
DHT11 - GND	GND
DHT11 - OUT	A0

Conexões de circuito no lado do receptor CAN:

Componente - Pin	Arduino UNO
MPC2515 - VCC	+ 5V
MPC2515 - GND	GND
MPC2515 - CS	10 (SPI_SS)
MPC2515 - SO	12 (SPI_MISO)
MPC2515 - SI	11 (SPI_MOSI)
MPC2515 - SCK	13 (SPI_SCK)
MPC2515 - INT	2
LCD - VSS	GND
LCD - VDD	+ 5V
LCD - V0	Para PIN do centro do potenciômetro de 10K
LCD - RS	3
LCD - RW	GND
LCD - E	4
LCD - D4	5
LCD - D5	6
LCD - D6	7
LCD - D7	8
LCD - A	+ 5V
LCD - K	GND

Conexão entre dois módulos CAN MCP2515

H - CAN alto

L - CAN Low

MCP2515 (Arduino Nano)	MCP2515 (Arduino UNO)
H	H
eu	eu

Depois que todas as conexões foram feitas, meu hardware ficou assim abaixo

Programando Arduino para comunicação CAN

Primeiro, temos que instalar uma biblioteca para CAN no Arduino IDE. A interface do módulo CAN MCP2515 com o Arduino se torna mais fácil usando a seguinte biblioteca.

Baixe o arquivo ZIP da biblioteca Arduino CAN MCP2515.
No IDE do Arduino: Sketch -> Incluir Biblioteca -> Adicionar Biblioteca.ZIP

Neste tutorial, a codificação é dividida em duas partes, uma como código do transmissor CAN (Arduino Nano) e outra como código do receptor CAN (Arduino UNO), ambas as quais podem ser encontradas na parte inferior desta página. A explicação para o mesmo é a seguinte.

Antes de escrever o programa para enviar e receber dados, certifique-se de ter instalado a biblioteca seguindo as etapas acima e que o módulo CAN MCP2515 seja inicializado em seu programa da seguinte forma.

Inicialize o módulo CAN MCP2515:

Para criar uma conexão com MCP2515, siga as etapas:

1. Defina o número do pino onde o SPI CS está conectado (10 por padrão)

MCP2515 mcp2515 (10);

2. Defina a taxa de transmissão e a frequência do oscilador

mcp2515.setBitrate (CAN_125KBPS, MCP_8MHZ);

Taxas de transmissão disponíveis:

CAN_5KBPS, CAN_10KBPS, CAN_20KBPS, CAN_31K25BPS, CAN_33KBPS, CAN_40KBPS, CAN_50KBPS, CAN_80KBPS, CAN_83K3BPS, CAN_95KBPS, CAN_100KBPS, CAN_125KBPS, CAN_250KBPS, CAN_250KBPS, CAN_250KBPS, CAN_250KBPS, CAN_250KBPS, CAN_250KBPS, CAN_250KBPS.

Velocidades de relógio disponíveis:

MCP_20MHZ, MCP_16MHZ, MCP_8MHZ

3. Defina os modos.

mcp2515.setNormalMode (); mcp2515.setLoopbackMode (); mcp2515.setListenOnlyMode ();

Explicação do código do lado do transmissor CAN (Arduino Nano)

Na seção do transmissor, o Arduino Nano faz interface com o módulo CAN MCP2515 por meio de pinos SPI e o DHT11 envia dados de temperatura e umidade para o barramento CAN.

Primeiro, as bibliotecas necessárias são incluídas, Biblioteca SPI para usar a Comunicação SPI, Biblioteca MCP2515 para usar a Comunicação CAN e Biblioteca DHT para usar o sensor DHT com Arduino . Anteriormente, fizemos a interface do DHT11 com o Arduino.

#incluir #incluir #incluir

Agora, o nome do pino DHT11 (pino OUT) que está conectado com o A0 do Arduino Nano está definido

# define DHTPIN A0

E também, o DHTTYPE é definido como DHT11.

# define DHTTYPE DHT11

Um tipo de dados de estrutura canMsg para armazenar o formato de mensagem CAN.

struct can_frame canMsg;

Defina o número do pino onde o SPI CS está conectado (10 por padrão)

MCP2515 mcp2515 (10);

E também, o objeto dht para classe DHT com pino DHT com Arduino Nano e tipo DHT como DHT11 é inicializado.

DHT dht (DHTPIN, DHTTYPE);

Próximo na configuração vazia ():

Comece a comunicação SPI usando a seguinte declaração

SPI.begin ();

E, em seguida, use a declaração abaixo para começar a receber os valores de temperatura e umidade do sensor DHT11.

dht.begin ();

Em seguida, o MCP2515 está sendo REINICIADO usando o seguinte comando

mcp2515.reset ();

Agora, o MCP2515 está definido como velocidade de 500KBPS e 8MHZ como clock

mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);

E o MCP2525 está configurado no modo normal

mcp2515.setNormalMode ();

No loop vazio ():

A instrução a seguir obtém o valor de Umidade e Temperatura e os armazena em uma variável inteira h e t.

int h = dht.readHumidity (); int t = dht.readTemperature ();

Em seguida, o CAN ID é dado como 0x036 (conforme a escolha) e DLC como 8 e damos os dados h e t aos dados e dados e colocamos todos os dados em 0.

canMsg.can_id = 0x036; canMsg.can_dlc = 8; canMsg.data = h; // Atualize o valor da umidade em canMsg.data = t; // Atualize o valor da temperatura em canMsg.data = 0x00; // Descanse tudo com 0 canMsg.data = 0x00; canMsg.data = 0x00; canMsg.data = 0x00; canMsg.data = 0x00; canMsg.data = 0x00;

Afinal, para enviar a mensagem ao CAN BUS utilizamos o seguinte enunciado.

mcp2515.sendMessage (& canMsg);

Agora, os dados de temperatura e umidade são enviados como mensagem para o barramento CAN.

Explicação do código do receptor CAN (Arduino UNO)

Na seção do receptor, o Arduino UNO fez interface com o MCP2515 e o display LCD 16x2. Aqui o Arduino UNO recebe a temperatura e a umidade do barramento CAN e exibe os dados recebidos no LCD.

Primeiro, as bibliotecas necessárias são incluídas, Biblioteca SPI para usar comunicação SPI, Biblioteca MCP2515 para usar comunicação CAN e Biblioteca LiquidCrsytal para usar LCD 16x2 com Arduino .

#incluir #incluir #incluir

Em seguida, os pinos de LCD que são usados na conexão com o Arduino UNO são definidos.

const int rs = 3, en = 4, d4 = 5, d5 = 6, d6 = 7, d7 = 8; LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

Um tipo de dados de estrutura é declarado para armazenar o formato de mensagem CAN.

struct can_frame canMsg;

Defina o número do pino onde o SPI CS está conectado (10 por padrão)

MCP2515 mcp2515 (10);

Na configuração vazia ():

Primeiro, o LCD é definido no modo 16x2 e uma mensagem de boas-vindas é exibida.

lcd.begin (16,2); lcd.setCursor (0,0); lcd.print ("CIRCUITO DIGEST"); lcd.setCursor (0,1); lcd.print ("CAN ARDUINO"); atraso (3000); lcd.clear ();

Comece a comunicação SPI usando a seguinte declaração.

SPI.begin ();

Em seguida, o MCP2515 está sendo RESET usando o seguinte comando.

mcp2515.reset ();

Agora, o MCP2515 está definido como velocidade de 500KBPS e 8MHZ como clock.

mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);

E o MCP2525 está configurado no modo normal.

mcp2515.setNormalMode ();

Próximo no loop void ():

A seguinte instrução é usada para receber a mensagem do barramento CAN. Se a mensagem for recebida, ela entrará na condição if .

if (mcp2515.readMessage (& canMsg) == MCP2515:: ERROR_OK)

Na condição if os dados são recebidos e armazenados em c anMsg , os dados que possuem valor de umidade e os dados que possuem valor de temperatura. Ambos os valores são armazenados em um inteiro x e y.

int x = canMsg.data; int y = canMsg.data;

Após receber os valores, os valores de temperatura e umidade são exibidos no display LCD 16x2 usando a seguinte declaração.

lcd.setCursor (0,0); lcd.print ("Umidade:"); lcd.print (x); lcd.setCursor (0,1); lcd.print ("Temp:"); lcd.print (y); atraso (1000); lcd.clear ();

Trabalho de comunicação CAN no Arduino

Assim que o hardware estiver pronto, carregue o programa para o transmissor CAN e o receptor CAN (programas completos são fornecidos abaixo) nas respectivas placas Arduino. Quando ligado, você deve notar que o valor de temperatura lido pelo DHT11 será enviado para outro Arduino através da comunicação CAN e exibido no LCD do ^2º Arduino como você pode ver na imagem abaixo. Também usei meu controle remoto AC para verificar se a temperatura exibida no LCD está próxima da temperatura ambiente real.

O trabalho completo pode ser encontrado no vídeo no link abaixo. Se você tiver alguma dúvida, deixe-a na seção de comentários ou use nossos fóruns para outras questões técnicas.