Módulo CAN BUS MCP2515 TJA1050 OBD-II: Manual Técnico Completo

Introdução

Neste manual, será apresentado como instalar, configurar e utilizar o Módulo CAN BUS MCP2515 TJA1050 OBD-II. Se desejar adquirir este produto, clique aqui.

O Módulo CAN BUS MCP2515 TJA1050 OBD-II (código SKU RB0552) é uma interface de comunicação industrial e automotiva compacta ($43 \times 28\,\text{mm}$) que integra em uma única placa o controlador de protocolo MCP2515 (Microchip Technology) e o transceptor diferencial de alta velocidade TJA1050 (NXP Semiconductors). Compatível com a especificação CAN V2.0B (Controller Area Network) em taxas de transmissão de até $1\,\text{Mbps}$ conforme a norma ISO 11898-2, o módulo converte barramentos síncronos SPI (Serial Peripheral Interface de até $10\,\text{MHz}$) de microcontroladores como Arduino, ESP32, STM32 e Raspberry Pi em sinais diferenciais imunes a ruído (CANH e CANL). Este documento foi estruturado como guia técnico de bancada e campo para engenheiros, técnicos de instrumentação automotiva e desenvolvedores de sistemas embarcados, detalhando limites elétricos absolutos, mapeamento de pinos, casamento de impedância de $120\,\Omega$, equacionamento temporal de bit timing e código-fonte completo para diagnóstico OBD-II (On-Board Diagnostics II).

Especificações técnicas

Principais especificações

As especificações construtivas, de protocolo e de arquitetura lógica do Módulo CAN BUS MCP2515 TJA1050 OBD-II estão consolidadas na tabela a seguir:

Parâmetro	Especificação
Modelo Comercial	Módulo Interface CAN BUS MCP2515 + TJA1050 SPI OBD-II
Código de Referência (SKU)	RB0552
Controlador de Protocolo CAN	Microchip MCP2515-I/SO (Encapsulamento SMD SOIC-18)
Transceptor de Camada Física (PHY)	NXP TJA1050 (Encapsulamento SMD SOIC-8, padrão ISO 11898-2)
Versão do Protocolo Suportada	CAN V2.0B Ativo (Suporta quadros Standard de $11\,\text{bits}$ e Extended de $29\,\text{bits}$)
Taxa de Transmissão no Barramento CAN	Até $1\,\text{Mb/s}$ ($5\,\text{kbps}$ a $1.000\,\text{kbps}$; padrões OBD-II típicos: $250\,\text{kbps}$ e $500\,\text{kbps}$)
Tamanho do Campo de Dados (Payload)	$0$ a $8\,\text{bytes}$ por quadro (Data Frame e Remote Request Frame — RTR)
Interface com o Microcontrolador	SPI (Serial Peripheral Interface) de alta velocidade até $10\,\text{MHz}$ — Modos SPI (0,0) e (1,1)
Oscilador a Cristal Integrado (X1)	Cristal de quartzo metálico HC-49S de $8{,}000\,\text{MHz}$ (verificar marcação no topo do cristal)
Buffers e Filtros em Hardware (MCP2515)	$3$ buffers de transmissão (TXB0–TXB2), $2$ buffers de recepção (RXB0, RXB1), $6$ filtros de aceitação ($29\,\text{bits}$) e $2$ máscaras
Terminação de Barramento Integrada	Resistor SMD de $120\,\Omega$ selecionável por jumper físico de 2 pinos (J1)
Capacidade Máxima de Nós na Rede	Mínimo de $110$ nós conectados ao mesmo par trançado diferencial (limitado pelo TJA1050)
Conectores de Campo e Lógica	Barra de 7 pinos machos $2{,}54\,\text{mm}$ (SPI/VCC), borne de parafuso duplo KF301 (CANH/CANL) e barra auxiliar de 2 pinos (H/L)
Indicador Visual na Placa	LED SMD vermelho (POW) indicador de presença de alimentação $+5\,\text{VDC}$
Dimensões Físicas ($C \times L$)	$43 \times 28\,\text{mm}$ ($4{,}3 \times 2{,}8\,\text{cm}$), com $4$ furos de fixação M3 espaçados em $38 \times 23\,\text{mm}$

Características elétricas e operacionais

Os parâmetros elétricos nominais e os limites máximos absolutos dos circuitos integrados MCP2515 e TJA1050 montados na placa estão discriminados abaixo:

Parâmetro Elétrico / Operacional	Mínimo	Típico	Máximo	Unidade	Condição / Observação Técnica
Tensão de Alimentação do Módulo ($V_{\text{CC}}$)	$4{,}75$	$5{,}00$	$5{,}25$	$\text{VDC}$	Faixa estrita exigida pelo transceptor TJA1050 (limite absoluto: $6{,}0\,\text{V}$)
Tensão de Operação Isolada do CI MCP2515	$2{,}70$	$5{,}00$	$5{,}50$	$\text{VDC}$	Na placa, o pino $V_{\text{DD}}$ do MCP2515 compartilha a malha VCC de $5{,}0\,\text{V}$
Nível Lógico Alto de Entrada SPI ($V_{\text{IH}}$)	$3{,}50$	$5{,}00$	$V_{\text{CC}} + 0{,}5$	$\text{V}$	$V_{\text{IH(mín)}} = 0{,}7 \cdot V_{\text{CC}}$ nos pinos CS, SCK e SI com $V_{\text{CC}} = 5{,}0\,\text{V}$
Nível Lógico Baixo de Entrada SPI ($V_{\text{IL}}$)	$-0{,}30$	$0{,}00$	$1{,}00$	$\text{V}$	$V_{\text{IL(máx)}} = 0{,}2 \cdot V_{\text{CC}}$ com alimentação em $5{,}0\,\text{V}$
Corrente de Trabalho do Controlador MCP2515	—	$5{,}0$	$10{,}0$	$\text{mA}$	Operação ativa SPI/CAN (em espera/Sleep: típico de $1\,\mu\text{A}$, exceto LED POW)
Corrente do Transceptor TJA1050 (Recessivo)	$2{,}5$	$5{,}0$	$10{,}0$	$\text{mA}$	Barramento em repouso lógico (TXD = HIGH, $V_{\text{diff}} \approx 0\,\text{V}$)
Corrente do Transceptor TJA1050 (Dominante)	$25{,}0$	$45{,}0$	$70{,}0$	$\text{mA}$	Durante transmissão de bit 0 dominante sobre carga diferencial de $60\,\Omega$
Tensão de Modo Comum Recessiva (CANH / CANL)	$2{,}00$	$2{,}50$	$3{,}00$	$\text{V}$	Ambos os fios repousam em $V_{\text{CC}}/2 \approx 2{,}5\,\text{V}$ em estado recessivo (bit 1)
Tensão Dominante na Linha CANH	$2{,}75$	$3{,}50$	$4{,}50$	$\text{V}$	Estado dominante (bit 0) com barramento terminado em $60\,\Omega$
Tensão Dominante na Linha CANL	$0{,}50$	$1{,}50$	$2{,}25$	$\text{V}$	Estado dominante (bit 0) com barramento terminado em $60\,\Omega$
Tensão Diferencial Dominante ($V_{\text{diff}}$)	$1{,}50$	$2{,}00$	$3{,}00$	$\text{V}$	$V_{\text{diff}} = V_{\text{CANH}} - V_{\text{CANL}}$ (limiar de recepção em $0{,}5\,\text{V}$ a $0{,}9\,\text{V}$)
Tolerância a Falhas nos Terminais CANH / CANL	$-27{,}0$	—	$+40{,}0$	$\text{V}$	Proteção contra curto-circuito direto à bateria automotiva ($12\,\text{V}$ / $24\,\text{V}$) e GND
Temperatura Industrial de Operação ($T_A$)	$-40$	$+25$	$+85$	$\text{°C}$	Grau industrial (MCP2515-I/SO); TJA1050 possui desligamento térmico em $+160\,\text{°C}$

Descrição do produto

O que é o Módulo CAN BUS MCP2515 TJA1050 OBD-II?

O Módulo CAN BUS MCP2515 TJA1050 OBD-II é uma placa adaptadora de rede industrial e veicular baseada em arquitetura bipartida, separando o processamento lógico da camada de enlace de dados (Data Link Layer — OSI Camada 2) do condicionamento elétrico diferencial da camada física (Physical Layer — OSI Camada 1). O circuito integrado MCP2515 da Microchip atua como controlador CAN autônomo (Stand-Alone CAN Controller), gerenciando integralmente em silício o enquadramento de mensagens, arbitragem não destrutiva de barramento por prioridade de identificador (CSMA/CD+AMP), inserção/remoção de bits de sincronismo (bit stuffing), cálculo de verificação cíclica de redundância (CRC de $15\,\text{bits}$), detecção de falhas e retransmissão automática de pacotes corrompidos, comunicando-se com qualquer microcontrolador hospedeiro por meio de quatro linhas SPI padrão mais um pino de interrupção externa (INT).

Na extremidade de campo, o circuito integrado TJA1050 da NXP converte os sinais lógicos unipolares TXCAN e RXCAN do controlador MCP2515 nos níveis diferenciais balanceados CANH e CANL exigidos pela norma ISO 11898-2. O TJA1050 incorpora controle de taxa de variação de borda (slew-rate control) para minimizar emissões eletromagnéticas (EME) em cabos de par trançado não blindados, estágio de saída em alta impedância quando desenergizado (evitando travar uma rede veicular ativa caso o módulo perca alimentação) e proteção contra transientes automotivos severos entre $-27\,\text{V}$ e $+40\,\text{V}$.

Para que serve?

• Diagnóstico veicular OBD-II, telemetria automotiva e dataloggers de pista: Leitura em tempo real de parâmetros da unidade de controle do motor (ECU — rotação RPM, velocidade, temperatura de arrefecimento, pressão de turbo, posição do acelerador e códigos de falha DTC) via porta padrão SAE J1962 / ISO 15765-4.
• Redes de automação industrial, máquinas agrícolas e protocolos J1939 / CANopen: Interligação multiponto robusta de sensores remotos, inversores de frequência, controladores lógicos programáveis (CLPs) e implementos pesados (SAE J1939 em caminhões e tratores) através de um único par trançado de longa distância.
• Robótica móvel distribuída, AGVs e controle de atuadores inteligentes: Comunicação determinística e imune a ruído eletromagnético de motores brushless/PWM entre o computador central do robô e múltiplos controladores de juntas robóticas ou sistemas de gerenciamento de baterias (BMS).

Por que devo usar?

• Processamento completo do protocolo CAN 2.0B em hardware dedicado: O MCP2515 descarrega 100% da validação de CRC, arbitragem de colisão, retransmissão e filtragem de IDs por máscaras em silício, permitindo que até microcontroladores de 8 bits como o ATmega328P (Arduino Uno/Nano) processem redes de $500\,\text{kbps}$ sem perda de pacotes.
• Alta imunidade a ruído por sinalização diferencial balanceada: Como o receptor avalia exclusivamente a diferença algébrica $V_{\text{CANH}} - V_{\text{CANL}}$, ruídos eletromagnéticos induzidos simultaneamente nos dois condutores do par trançado (modo comum) anulam-se mutuamente, permitindo alcances de até $40\,\text{m}$ a $1\,\text{Mbps}$ ou até $500\,\text{m}$ a $125\,\text{kbps}$.
• Terminação de $120\,\Omega$ integrada e dupla opção de conexão física: A presença do resistor de fim de linha selecionável por jumper (J1) somada ao borne de parafuso KF301 e à barra de pinos paralela dispensa componentes externos em prototipagem de bancada e instalações definitivas em chicotes veiculares.

Quando devo usar?

Este módulo é a escolha recomendada sempre que o microcontrolador principal não possuir controlador CAN interno (como Arduino Uno, Nano, Mega 2560, Pro Mini, ATtiny, Raspberry Pi e ESP8266) ou quando for necessário adicionar um segundo ou terceiro barramento CAN independente (Dual/Triple CAN Gateway) a microcontroladores como o ESP32 ou STM32, operando em redes CAN 2.0A/2.0B clássicas até $1\,\text{Mbps}$ com alimentação disponível de $5{,}0\,\text{VDC}$.

Por outro lado, este módulo não deve ser utilizado diretamente nos seguintes cenários:

• Redes automotivas modernas baseadas em CAN FD (Flexible Data-Rate): Veículos recentes que trafegam quadros de até $64\,\text{bytes}$ e taxas de dados de $2\,\text{Mbps}$ a $8\,\text{Mbps}$ são incompatíveis com o MCP2515 clássico (que rejeita quadros FD como erro de formato). Para redes CAN FD via SPI, utilize um módulo baseado no controlador MCP2518FD ou MCP2517FD.
• Sistemas portáteis alimentados exclusivamente em $3{,}3\,\text{V}$ sem barramento de $5{,}0\,\text{V}$: O transceptor TJA1050 entra em bloqueio por subtensão abaixo de $4{,}75\,\text{V}$ e não opera em $3{,}3\,\text{V}$. Se utilizar um ESP32 (que já possui controlador CAN/TWAI nativo interno) em placa de $3{,}3\,\text{V}$ puro, prefira o transceptor SN65HVD230 ($3{,}3\,\text{V}$).
• Ambientes com grandes diferenças de potencial de terra ou inversores de alta tensão sem isolação: Para acoplar sistemas de controle a inversores solares ou bancos de baterias de tração elétrica onde há risco de ground loop destrutivo, utilize transceptores CAN com isolação galvânica integrada (como ISO1050 ou ADM3053).

Pinout e diagrama de entradas/saídas

O Módulo CAN BUS MCP2515 TJA1050 dispõe de três interfaces de conexão na placa: a barra principal de 7 pinos (J2) para alimentação e barramento SPI, os conectores de campo em paralelo (borne de parafuso J3 e pinos H/L) para o barramento diferencial CAN, e o jumper J1 de terminação de impedância, detalhados na tabela abaixo:

Conector / Serigrafia	Nome Técnico	Direção (Relativa ao Módulo)	Nível Elétrico	Função Técnica Detalhada
VCC (J2)	Alimentação Positiva	Entrada	$+5{,}0\,\text{VDC}$ ($\pm 5\%$)	Alimentação geral do controlador MCP2515, do transceptor TJA1050 e do LED POW.
GND (J2)	Referência de Terra	Referência	$0\,\text{V}$	Referência comum de alimentação e sinal lógico SPI/CAN.
CS (J2)	Chip Select ($\overline{\text{CS}}$)	Entrada Lógica	$5\,\text{V}$ TTL/CMOS	Seleção do escravo SPI ativo em nível baixo (LOW). Inicia e encerra transações de comando/dados com o MCP2515.
SO (J2)	Slave Out (MISO)	Saída Lógica	$0\,\text{V}$ / $+5{,}0\,\text{V}$	Saída serial de dados do MCP2515 para o pino MISO do microcontrolador. Fica em alta impedância (Hi-Z) quando CS = HIGH.
SI (J2)	Slave In (MOSI)	Entrada Lógica	$5\,\text{V}$ ($V_{\text{IH}} \ge 3{,}5\,\text{V}$)	Entrada serial de comandos e dados vindos do pino MOSI do microcontrolador mestre.
SCK (J2)	Serial Clock	Entrada Lógica	$5\,\text{V}$ ($f \le 10\,\text{MHz}$)	Entrada de clock síncrono SPI gerado pelo microcontrolador mestre.
INT (J2)	Interrupt ($\overline{\text{INT}}$)	Saída Lógica	Ativo Baixo ($5\,\text{V}$)	Saída de interrupção (possui resistor pull-up SMD de $10\,\text{k}\Omega$ para VCC na placa). Vai para LOW quando um quadro válido chega nos buffers RXB0/RXB1 ou ocorre evento de erro.
H / CANH (Borne / Pino)	CAN High	Bidirecional Diferencial	$2{,}5\,\text{V}$ (Rec.) / $3{,}5\,\text{V}$ (Dom.)	Linha diferencial positiva do barramento físico CAN (ISO 11898-2). Conectada ao pino 7 do CI TJA1050.
L / CANL (Borne / Pino)	CAN Low	Bidirecional Diferencial	$2{,}5\,\text{V}$ (Rec.) / $1{,}5\,\text{V}$ (Dom.)	Linha diferencial negativa do barramento físico CAN (ISO 11898-2). Conectada ao pino 6 do CI TJA1050.
J1 (Jumper 2 Pinos)	Terminação de $120\,\Omega$	Chave Física	Passivo ($120\,\Omega$)	Fechado: insere o resistor SMD de $120\,\Omega$ (R1/121) entre CANH e CANL. Aberto: desconecta a terminação local.

Para aplicações automotivas na porta de diagnóstico OBD-II (conector fêmea trapezoidal SAE J1962 de 16 pinos no painel do veículo), utilize rigorosamente a referência padronizada da norma ISO 15765-4:

Pino no Conector OBD-II (Veículo)	Sinal Oficial SAE J1962	Conexão no Módulo MCP2515	Observação de Engenharia
Pino 6	CAN High (ISO 15765-4)	Borne H (CANH)	Par trançado positivo da rede CAN de alta velocidade ($500\,\text{kbps}$)
Pino 14	CAN Low (ISO 15765-4)	Borne L (CANL)	Par trançado negativo da rede CAN de alta velocidade ($500\,\text{kbps}$)
Pino 5	Signal Ground (Terra de Sinal)	Pino GND (Comum)	Referência de modo comum recomendada para o transceptor TJA1050
Pino 4	Chassis Ground (Terra de Chassi)	Uso apenas para fonte DC	Terra metálico da carroceria do veículo
Pino 16	Bateria $+12\,\text{V}$ Permanente	NUNCA ligar direto no módulo!	Usar somente através de conversor step-down automotivo isolado/protegido de $12\,\text{V} \to 5\,\text{V}$

Como fazer a ligação

Requisitos de instalação e alimentação

1. Fonte de alimentação estabilizada de $5{,}0\,\text{VDC}$:
   • O transceptor TJA1050 exige estritamente tensão entre $4{,}75\,\text{VDC}$ e $5{,}25\,\text{VDC}$ no pino VCC, com pico de corrente de até $70\,\text{mA}$ durante a transmissão de bits dominantes. Em placas Arduino Uno / Nano / Mega, o pino 5V regulado supre o módulo diretamente com folga.
   • Em instalações veiculares permanentes alimentadas pelo pino 16 do conector OBD-II ($12\,\text{V}$ a $14{,}4\,\text{V}$ com alternador em carga), utilize um regulador buck automotivo de $5{,}0\,\text{VDC}$ acompanhado de diodo supressor de transientes (TVS) para suportar picos de partida (load dump).
2. Compatibilização de nível lógico para microcontroladores de $3{,}3\,\text{V}$ (ESP32, RP2040, STM32):
   • Conforme a folha de dados oficial da Microchip (DS20001801), os pinos de entrada SPI do MCP2515 exigem nível alto mínimo $V_{\text{IH}} = 0{,}7 \cdot V_{\text{DD}}$. Quando alimentado em $V_{\text{DD}} = 5{,}0\,\text{V}$, tem-se $V_{\text{IH(mín)}} = 3{,}50\,\text{V}$ (acima dos $3{,}3\,\text{V}$ de saída de um ESP32). Simultaneamente, os pinos de saída SO (MISO) e INT do módulo entregam $5{,}0\,\text{V}$, o que excede o limite máximo de $3{,}6\,\text{V}$ dos GPIOs do ESP32.
   • Portanto, ao conectar o módulo a um ESP32, alimente VCC do módulo em $5{,}0\,\text{V}$ e intercale um conversor de nível lógico bidirecional de 4 ou 8 canais ($3{,}3\,\text{V} \leftrightarrow 5{,}0\,\text{V}$, tipo BSS138 ou TXS0108E) nas linhas CS, SCK, SI, SO e INT.
3. Cabeamento diferencial em par trançado (Twisted Pair):
   • Utilize sempre um par de fios trançados (ex.: um par extraído de cabo UTP Cat5e/Cat6 ou cabo industrial CAN dedicado de impedância característica $Z_0 = 120\,\Omega$, bitola $24\,\text{AWG}$ a $20\,\text{AWG}$) para interligar CANH com CANH e CANL com CANL entre todos os nós da rede. Nunca inverta CANH com CANL.

Diagrama de ligação elétrica

A figura abaixo ilustra o diagrama de ligação elétrica em blocos do Módulo CAN BUS MCP2515 TJA1050 OBD-II, demonstrando a alimentação regulada de $5\,\text{VDC}$, a conexão direta da interface SPI com um Arduino Uno R3, o acoplamento à porta veicular OBD-II e a topologia de barramento CAN diferencial com terminação de $120\,\Omega$:

No arranjo apresentado, o microcontrolador mestre controla o controlador MCP2515 através das quatro linhas síncronas SPI (CS, SI, SO, SCK) e monitora a chegada de quadros em tempo real pela interrupção externa INT. No lado diferencial de campo, os terminais H (CANH) e L (CANL) conectam-se diretamente em paralelo ao barramento CAN existente — seja a uma rede industrial entre dois ou mais módulos (com J1 fechado apenas nas duas extremidades físicas do cabo tronco) ou aos pinos 6 e 14 da tomada OBD-II do veículo (mantendo J1 aberto).

Tabela de conexões dos terminais

O mapeamento completo ponto a ponto (De $\to$ Para) para integração direta em $5\,\text{V}$ (Arduino Uno / Nano) e conexão ao barramento CAN / OBD-II está detalhado na tabela a seguir:

Terminal de Origem (MCU / Fonte / Rede)	Terminal de Destino (Módulo MCP2515)	Cor Sugerida do Fio	Tipo de Sinal	Observação Técnica
Saída +5V (Arduino Uno / Fonte 5V)	Pino VCC (J2)	Vermelho	Alimentação DC ($+5{,}0\,\text{V}$)	Obrigatório $4{,}75\,\text{V}$ a $5{,}25\,\text{V}$ para operar o TJA1050
Saída GND (Arduino Uno / Fonte 5V)	Pino GND (J2)	Preto	Terra Comum ($0\,\text{V}$)	Referência comum lógica e de alimentação
Pino D10 / SS (Arduino Uno)	Pino CS (J2)	Amarelo	Saída Digital SPI ($\overline{\text{CS}}$)	No Arduino Mega 2560, usar pino D53 (ou D10)
Pino D11 / MOSI (Arduino Uno)	Pino SI (J2)	Azul	Dados SPI Mestre $\to$ Escravo	No Arduino Mega 2560, usar pino D51
Pino D12 / MISO (Arduino Uno)	Pino SO (J2)	Verde	Dados SPI Escravo $\to$ Mestre	No Arduino Mega 2560, usar pino D50
Pino D13 / SCK (Arduino Uno)	Pino SCK (J2)	Laranja	Clock Síncrono SPI	No Arduino Mega 2560, usar pino D52
Pino D2 / INT0 (Arduino Uno)	Pino INT (J2)	Branco ou Roxo	Interrupção Externa ($\overline{\text{IRQ}}$)	Dispara borda de descida (FALLING) ao receber pacote
Pino 6 OBD-II / Linha CAN_H da Rede	Borne H (CANH)	Amarelo ou Branco (Par Trançado)	Sinal Diferencial CAN High	Ligar sempre CANH com CANH em todos os nós
Pino 14 OBD-II / Linha CAN_L da Rede	Borne L (CANL)	Verde ou Azul (Par Trançado)	Sinal Diferencial CAN Low	Ligar sempre CANL com CANL em todos os nós
Pino 5 OBD-II (Signal Ground)	Pino GND (Comum)	Preto	Referência de Modo Comum	Evita deslocamento de potencial entre veículo e leitor

Caso utilize um ESP32 (Barramento VSPI padrão em $3{,}3\,\text{V}$), conecte VCC do módulo ao pino 5V / VIN (USB) e passe os 5 sinais digitais por um Conversor de Nível Lógico Bidirecional ($3{,}3\,\text{V}$ LV $\leftrightarrow$ $5{,}0\,\text{V}$ HV) seguindo este mapeamento:

Pino no ESP32 (3.3V — Lado LV)	Pino no Módulo MCP2515 (5.0V — Lado HV)	Função no Barramento VSPI
GPIO 5 (VSPI SS)	Pino CS	Seleção do chip escravo ($\overline{\text{CS}}$)
GPIO 23 (VSPI MOSI)	Pino SI	Dados Mestre $\to$ Escravo (MOSI)
GPIO 19 (VSPI MISO)	Pino SO	Dados Escravo $\to$ Mestre (MISO protegido contra $5\,\text{V}$)
GPIO 18 (VSPI SCK)	Pino SCK	Clock SPI de alta velocidade
GPIO 4 (ou GPIO 21)	Pino INT	Entrada de interrupção externa ($\overline{\text{INT}}$ protegida contra $5\,\text{V}$)

Cuidados e observações de segurança

⛔ Perigo: Jamais transmita pacotes CAN arbitrários ou de força bruta (fuzzing) na rede OBD-II de um veículo em movimento em vias públicas! Em veículos modernos, módulos críticos como direção elétrica assistida (EPS), freios ABS/ESP, controle de transmissão automática e carroceria compartilham gateways CAN. Injetar identificadores desconhecidos ou causar excesso de quadros de erro (Bus-Off) com o carro em deslocamento pode desabilitar assistências de segurança ou acionar modos de emergência (limp mode) no motor. Em veículos reais, inicie sempre em modo somente escuta (Listen-Only) ou restrinja-se a requisições padronizadas de diagnóstico (0x7DF) com o veículo estacionado em local seguro.

⚠️ Atenção: Não alimente o pino VCC deste módulo com $3{,}3\,\text{V}$ esperando que o barramento físico funcione, nem conecte os pinos SO e INT diretamente a um ESP32 sem conversão de nível! Alimentado em $3{,}3\,\text{V}$, o MCP2515 responderá normalmente via SPI (passando no teste de Loopback interno), mas o transceptor TJA1050 permanecerá inoperante no barramento físico por exigir no mínimo $4{,}75\,\text{VDC}$. Por outro lado, alimentar o módulo em $5{,}0\,\text{V}$ e ligar SO/INT direto nas portas de $3{,}3\,\text{V}$ do ESP32 aplica sobretensão contínua nos diodos de proteção internos do microcontrolador, podendo danificá-lo permanentemente.

💡 Dica: Antes de energizar qualquer rede CAN, desligue todos os nós da alimentação e meça com um multímetro digital na escala de resistência ($\Omega$) entre os terminais CANH e CANL do barramento completo. Uma rede CAN corretamente terminada (com dois resistores de $120\,\Omega$ em paralelo nas duas pontas do cabo tronco) deve apresentar exatamente $60\,\Omega$ ($\pm 5\,\Omega$). Se o multímetro medir $120\,\Omega$, falta fechar o jumper J1 no segundo nó da extremidade; se medir $40\,\Omega$ ou menos, há nós intermediários demais com o jumper J1 fechado (como ao ligar o módulo com J1 fechado em uma porta OBD-II veicular que já possui $60\,\Omega$ internos).

Como usar

Guia de operação passo a passo

1. Identifique a frequência do cristal oscilador (X1) na placa: Inspecione visualmente o invólucro metálico prateado ao lado do CI MCP2515. No modelo RB0552, a gravação no topo indica 8.000 ($8\,\text{MHz}$). Caso possua outro lote marcado como 16.000 ($16\,\text{MHz}$), ajuste a constante de clock no código (MCP_8MHZ vs. MCP_16MHZ), pois configurar o cristal errado reduz ou dobra a taxa real de bits pela metade, impedindo qualquer comunicação no barramento.
2. Configure o jumper J1 de terminação ($120\,\Omega$):
   • Teste de bancada entre 2 módulos MCP2515: Feche o jumper J1 nos dois módulos (obtendo $120\,\Omega \parallel 120\,\Omega = 60\,\Omega$).
   • Conexão à porta OBD-II de um automóvel: Deixe o jumper J1 ABERTO (sem conector), pois o chicote original do veículo já incorpora os dois resistores de $120\,\Omega$ nas ECUs extremas.
3. Instale a biblioteca na Arduino IDE: Abra o Library Manager (Sketch $\to$ Include Library $\to$ Manage Libraries...), pesquise por MCP_CAN_lib (autor Cory J. Fowler) e instale a versão mais recente (compatível com AVR, ESP32, STM32 e RP2040).
4. Valide a fiação SPI com o modo Loopback antes de conectar ao veículo: Carregue o código de exemplo abaixo e acione o comando [L] no Monitor Serial ($115200\,\text{bps}$). No modo Loopback, o MCP2515 roteia internamente seus buffers de transmissão para os de recepção sem depender do cabo externo — se o teste aprovar, toda a fiação SPI (CS, SI, SO, SCK, INT) está 100% funcional.
5. Comute para modo Normal ou Listen-Only no barramento real: Conecte o par trançado CANH/CANL na velocidade exata da rede alvo ($500\,\text{kbps}$ para carros OBD-II a partir de 2008; $250\,\text{kbps}$ para caminhões pesados SAE J1939) e inicie a leitura ou requisição de parâmetros.

Modos de operação e ajustes

Equacionamento da camada física diferencial, terminação e Bit Timing

Na camada física ISO 11898-2 implementada pelo transceptor TJA1050, a informação binária é codificada pela diferença de potencial ($V_{\text{diff}}$) entre os condutores CANH e CANL:

$$V_{\text{diff}} = V_{\text{CANH}} - V_{\text{CANL}}$$

• Bit Recessivo (1 lógico — estado ocioso): Os transistores diferenciais do TJA1050 permanecem desligados, polarizando ambas as linhas em $V_{\text{CANH}} \approx V_{\text{CANL}} \approx 2{,}5\,\text{V}$, resultando em $V_{\text{diff}} \approx 0{,}0\,\text{V}$ ($< 0{,}5\,\text{V}$).
• Bit Dominante (0 lógico — prioridade ativa): O TJA1050 traciona CANH para $\approx 3{,}5\,\text{V}$ e drena CANL para $\approx 1{,}5\,\text{V}$, gerando $V_{\text{diff}} \approx 2{,}0\,\text{V}$ ($\ge 0{,}9\,\text{V}$). Qualquer nó que escreva um bit dominante (0) sobrescreve nós que transmitam bit recessivo (1), viabilizando a arbitragem de prioridade sem destruição do quadro vencedor.

Para evitar reflexões de onda estacionária nas bordas rápidas de sinal sobre o par trançado de impedância característica $Z_0 = 120\,\Omega$, o barramento exige exatamente dois resistores de terminação $R_T = 120\,\Omega$ posicionados nas extremidades físicas opostas da linha, produzindo a resistência equivalente DC medida no barramento:

$$R_{\text{bus}} = \frac{R_{T1} \cdot R_{T2}}{R_{T1} + R_{T2}} = \frac{120\,\Omega \times 120\,\Omega}{120\,\Omega + 120\,\Omega} = 60\,\Omega$$

No interior do controlador MCP2515, cada bit transmitido no barramento CAN é subdividido em múltiplos intervalos elementares de tempo denominados Time Quanta ($T_Q$), derivados da frequência do cristal oscilador externo ($f_{\text{OSC}} = 8\,\text{MHz}$) e do divisor programável de Baud Rate Prescaler ($\text{BRP} \in [0..63]$ nos registradores CNF1/CNF2/CNF3):

$$T_Q = \frac{2 \cdot (\text{BRP} + 1)}{f_{\text{OSC}}}$$

Cada tempo nominal de bit ($t_{\text{BIT}}$) compreende a soma de quatro segmentos temporais discretos: segmento de sincronismo fixo ($t_{\text{SyncSeg}} = 1\,T_Q$), segmento de propagação ($t_{\text{PropSeg}}$), segmento de fase 1 ($t_{\text{PS1}}$ — ponto de amostragem do bit) e segmento de fase 2 ($t_{\text{PS2}}$). Assim, a taxa de comunicação resultante ($f_{\text{BIT}}$) é governada pela equação:

$$f_{\text{BIT}} = \frac{f_{\text{OSC}}}{2 \cdot (\text{BRP} + 1) \cdot \left(1 + t_{\text{PropSeg}} + t_{\text{PS1}} + t_{\text{PS2}}\right)}$$

Por exemplo, com o cristal padrão da placa de $f_{\text{OSC}} = 8\,\text{MHz}$, configurando $\text{BRP} = 0$ e total de $N_{\text{TQ}} = 8\,T_Q$ por bit ($1 + 2 + 3 + 2 = 8\,T_Q$, ponto de amostragem em $75\%$), obtém-se exatamente a velocidade automotiva OBD-II de alta velocidade:

$$f_{\text{BIT}} = \frac{8 \times 10^6\,\text{Hz}}{2 \cdot (0 + 1) \cdot 8} = 500.000\,\text{bps} = 500\,\text{kbps}$$

Modos de operação internos do controlador MCP2515 e tabela do Jumper J1

O registrador CANCTRL do MCP2515 permite selecionar cinco estados operacionais distintos via software, enquanto o jumper J1 define a carga física na linha:

| Modo Operacional (MCP2515) | Constante MCP_CAN_lib | Comportamento no Barramento Físico | Aplicação Principal | |---|---|---| | Configuração (Config) | (Automático no begin) | Inativo; único modo que habilita escrita nos registradores de baud rate (CNF1–CNF3), máscaras e filtros. | Inicialização do chip após reset | | Normal (Normal Mode) | MCP_NORMAL | Participa integralmente da rede: transmite quadros, recebe mensagens e envia bit dominante de confirmação (ACK). | Operação padrão e scanner OBD-II ativo | | Somente Escuta (Listen-Only) | MCP_LISTENONLY | Silencia completamente o pino TXCAN (não envia nem o bit de ACK nem Error Frames), capturando todo o tráfego de forma 100% passiva. | Sniffer / Engenharia reversa veicular segura | | ** Autoteste (Loopback)** | MCP_LOOPBACK | Conecta internamente os buffers TXB aos RXB ignorando o barramento externo (TXCAN permanece recessivo). | Diagnóstico isolado da fiação SPI sem 2º nó | | Hibernação (Sleep Mode) | MCP_SLEEP | Desliga o oscilador interno de $8\,\text{MHz}$, reduzindo o consumo do MCP2515 para $\approx 1\,\mu\text{A}$ até despertar via SPI ou atividade no barramento. | Economia de bateria com ignição desligada |

Cenário de Topologia de Rede	Posição Física do Módulo	Estado Obrigatório do Jumper J1 ($120\,\Omega$)
Rede ponto a ponto de bancada (2 módulos MCP2515)	Extremidade A e Extremidade B do par trançado	FECHADO em ambos os módulos
Rede industrial multiponto ($3$ ou mais nós)	Apenas nos 2 nós das pontas extremas do cabo tronco	FECHADO nas 2 pontas / ABERTO nos nós do meio
Diagnóstico automotivo via conector OBD-II	Derivação curta (stub) acoplada à rede original do carro	ABERTO (o veículo já possui $60\,\Omega$ internos)

Exemplos práticos de uso

Autoteste SPI (Loopback), Sniffer CAN 2.0B e Scanner de Telemetria OBD-II (Arduino e ESP32)

O firmware completo abaixo foi projetado como ferramenta profissional de bancada e diagnóstico veicular, sendo 100% compatível tanto com Arduino Uno / Nano / Mega quanto com ESP32 (utilizando conversor de nível lógico bidirecional). Através de comandos simples pelo Monitor Serial ($115200\,\text{bps}$), o código permite:

1. Validar instantaneamente o hardware e o cristal de $8\,\text{MHz}$ em modo Loopback ([L]) mesmo com apenas um módulo na mesa;
2. Operar como Analisador Passivo / Sniffer ([S]) sem interferir no barramento;
3. Operar em Modo Normal ([N]) a $500\,\text{kbps}$ e requisitar ciclicamente parâmetros reais OBD-II Serviço 0x01 ([O]) no ID funcional padrão 0x7DF — decodificando matematicamente Rotação do Motor (PID 0x0C), Velocidade do Veículo (PID 0x0D) e Temperatura do Líquido de Arrefecimento (PID 0x05) respondidos pela ECU (0x7E8).

/**
 * ============================================================================
 * Projeto: Diagnostico CAN 2.0B (Loopback / Sniffer) e Scanner OBD-II (ISO 15765-4)
 * Modulo Analisado: Modulo CAN BUS MCP2515 + TJA1050 OBD-II (SKU: RB0552)
 * Biblioteca Requerida: "MCP_CAN_lib" por Cory J. Fowler (Gerenciador Arduino IDE)
 * Plataformas Suportadas: Arduino (Uno/Nano/Mega) e ESP32 (com Level Shifter 5V)
 * Importante: Cristal padrao do modulo RB0552 = 8.000 MHz (MCP_8MHZ)
 * ============================================================================
 */

#include <Arduino.h>
#include <SPI.h>
#include <mcp_can.h>

// Definicao automatica dos pinos CS e INT conforme a arquitetura compilada
#if defined(ESP32)
  const uint8_t PIN_CAN_CS  = 5;   // VSPI CS -> Conversor de Nivel -> CS do MCP2515
  const uint8_t PIN_CAN_INT = 4;   // GPIO 4  <- Conversor de Nivel <- INT do MCP2515
#else
  const uint8_t PIN_CAN_CS  = 10;  // Pino D10 (SS) -> CS do MCP2515
  const uint8_t PIN_CAN_INT = 2;   // Pino D2 (INT0) <- INT do MCP2515
#endif

// Ajuste conforme a marcacao no cristal metalico do modulo: MCP_8MHZ ou MCP_16MHZ
#define CRISTAL_MODULO     MCP_8MHZ
#define VELOCIDADE_PADRAO  CAN_500KBPS

// Identificadores padrao de diagnostico OBD-II (11 bits - ISO 15765-4)
const uint32_t OBD2_ID_REQUISICAO   = 0x7DF; // Broadcast funcional para todas as ECUs
const uint32_t OBD2_ID_RESPOSTA_MIN = 0x7E8; // Resposta da ECU Primária do Motor (ECM)
const uint32_t OBD2_ID_RESPOSTA_MAX = 0x7EF;

// PIDs do Modo/Servico 0x01 (Dados Atuais do Powertrain)
const uint8_t PID_TEMP_ARREFECIMENTO = 0x05; // Formula: A - 40 (°C)
const uint8_t PID_ROTACAO_MOTOR_RPM  = 0x0C; // Formula: ((256 * A) + B) / 4 (rpm)
const uint8_t PID_VELOCIDADE_KMH     = 0x0D; // Formula: A (km/h)

MCP_CAN CAN0(PIN_CAN_CS);

bool telemetriaObdAtiva = false;
uint32_t ultimoDisparoObdMs = 0;
uint8_t indicePidAtual = 0;

/**
 * Envia uma requisicao de diagnostico OBD-II (Servico 0x01) para o PID informado
 */
bool requisitarPidObd2(uint8_t pid) {
  // Estrutura ISO 15765-2 Single Frame (8 bytes):
  // [0]=0x02 (2 bytes uteis seguintes), [1]=0x01 (Servico Dados Atuais), [2]=PID, [3..7]=Padding 0x55
  byte quadroReq[8] = {0x02, 0x01, pid, 0x55, 0x55, 0x55, 0x55, 0x55};
  byte status = CAN0.sendMsgBuf(OBD2_ID_REQUISICAO, 0, 8, quadroReq);
  return (status == CAN_OK);
}

/**
 * Interpreta e exibe respostas OBD-II (Servico 0x41 = Resposta positiva ao Servico 0x01)
 */
void decodificarRespostaObd2(uint32_t rxId, uint8_t len, const uint8_t *buf) {
  if (len < 4 || buf[1] != 0x41) {
    return; // Nao e resposta positiva do Servico 0x01
  }

  uint8_t pidRespondido = buf[2];
  uint8_t byteA = buf[3];
  uint8_t byteB = (len >= 5) ? buf[4] : 0;

  Serial.print(F("[OBD-II ECU 0x"));
  Serial.print(rxId, HEX);
  Serial.print(F("] "));

  switch (pidRespondido) {
    case PID_TEMP_ARREFECIMENTO: {
      int16_t tempC = (int16_t)byteA - 40;
      Serial.print(F("Temperatura do Motor: "));
      Serial.print(tempC);
      Serial.println(F(" °C"));
      break;
    }
    case PID_ROTACAO_MOTOR_RPM: {
      float rpm = ((256.0f * (float)byteA) + (float)byteB) / 4.0f;
      Serial.print(F("Rotacao do Motor: "));
      Serial.print(rpm, 0);
      Serial.println(F(" RPM"));
      break;
    }
    case PID_VELOCIDADE_KMH: {
      Serial.print(F("Velocidade Veicular: "));
      Serial.print(byteA);
      Serial.println(F(" km/h"));
      break;
    }
    default:
      Serial.print(F("PID 0x"));
      Serial.print(pidRespondido, HEX);
      Serial.print(F(" = A:0x"));
      Serial.println(byteA, HEX);
      break;
  }
}

/**
 * Le e imprime qualquer quadro CAN pendente nos buffers RXB0 / RXB1 do MCP2515
 */
void processarQuadrosRecebidos() {
  // O pino INT permanece em nivel LOW enquanto houver mensagens nos buffers do MCP2515
  while (digitalRead(PIN_CAN_INT) == LOW) {
    long unsigned int rxId = 0;
    unsigned char len = 0;
    unsigned char rxBuf[8];

    if (CAN0.readMsgBuf(&rxId, &len, rxBuf) == CAN_OK) {
      bool idEstendido = ((rxId & 0x80000000UL) == 0x80000000UL);
      bool quadroRemoto = ((rxId & 0x40000000UL) == 0x40000000UL);
      uint32_t idLimpo = idEstendido ? (rxId & 0x1FFFFFFFUL) : (rxId & 0x7FFUL);

      // Exibe log hexadecimal bruto do barramento
      Serial.print(idEstendido ? F("[RX EXT] ID: 0x") : F("[RX STD] ID: 0x"));
      Serial.print(idLimpo, HEX);
      Serial.print(F(" | DLC: "));
      Serial.print(len);
      Serial.print(F(" | Dados:"));

      if (quadroRemoto) {
        Serial.println(F(" [QUADRO RTR - REQUISICAO REMOTA]"));
      } else {
        for (uint8_t i = 0; i < len; i++) {
          Serial.print(rxBuf[i] < 0x10 ? F(" 0") : F(" "));
          Serial.print(rxBuf[i], HEX);
        }
        Serial.println();

        // Se o ID estiver na faixa de ECUs OBD-II (0x7E8..0x7EF), decodifica grandezas fisicas
        if (!idEstendido && idLimpo >= OBD2_ID_RESPOSTA_MIN && idLimpo <= OBD2_ID_RESPOSTA_MAX) {
          decodificarRespostaObd2(idLimpo, len, rxBuf);
        }
      }
    } else {
      break;
    }
  }
}

/**
 * Executa um autoteste interno completo (Loopback) para validar a ligacao SPI
 */
void executarAutotesteLoopback() {
  telemetriaObdAtiva = false;
  Serial.println(F("\n[TESTE] Alternando MCP2515 para modo LOOPBACK interno..."));
  CAN0.setMode(MCP_LOOPBACK);
  delay(20);

  byte payloadTeste[8] = {0x52, 0x42, 0x05, 0x52, 0xCA, 0xFE, 0x20, 0x26}; // Assinatura RB0552
  byte res = CAN0.sendMsgBuf(0x123, 0, 8, payloadTeste);

  if (res == CAN_OK) {
    Serial.println(F("[OK] Quadro 0x123 injetado no buffer TXB. Verificando recepcao em RXB..."));
    delay(20);
    processarQuadrosRecebidos();
    Serial.println(F("[SUCESSO] Comunicacao SPI, Cristal 8 MHz e pino INT validados com exito!"));
  } else {
    Serial.print(F("[FALHA] Erro ao transmitir em Loopback. Codigo: "));
    Serial.println(res);
  }
}

void imprimirMenuSerial() {
  Serial.println(F("\n======================================================================"));
  Serial.println(F("  CONSOLE TECNICO - MODULO CAN BUS MCP2515 + TJA1050 (SKU: RB0552)"));
  Serial.println(F("  Comandos disponiveis (115200 bps):"));
  Serial.println(F("  [L] Autoteste de Bancada em LOOPBACK (valida SPI sem 2o modulo)"));
  Serial.println(F("  [S] Modo SNIFFER Passivo (Listen-Only 500 kbps - seguro para carros)"));
  Serial.println(F("  [N] Modo NORMAL Ativo (500 kbps - envia quadro de teste ID 0x100)"));
  Serial.println(F("  [O] Iniciar/Parar Scanner de Telemetria OBD-II (RPM, Km/h, Temp)"));
  Serial.println(F("======================================================================"));
}

void setup() {
  Serial.begin(115200);
  delay(500);
  pinMode(PIN_CAN_INT, INPUT_PULLUP);

  Serial.println(F("Inicializando controlador Microchip MCP2515 via SPI..."));

  // MCP_ANY desabilita mascaras/filtros iniciais para aceitar qualquer ID padrao ou estendido
  if (CAN0.begin(MCP_ANY, VELOCIDADE_PADRAO, CRISTAL_MODULO) == CAN_OK) {
    Serial.println(F("[OK] MCP2515 inicializado com sucesso a 500 kbps (Cristal 8 MHz)!"));
  } else {
    Serial.println(F("[ERRO CRITICO] Falha na comunicacao SPI com o MCP2515!"));
    Serial.println(F(" -> Verifique VCC (5V), GND, pino CS, SI (MOSI), SO (MISO) e SCK."));
    while (true) {
      delay(1000);
    }
  }

  // Inicia por seguranca em modo Listen-Only ate o usuario escolher o modo desejado
  CAN0.setMode(MCP_LISTENONLY);
  Serial.println(F("[INFO] Modulo em modo seguro LISTEN-ONLY (Somente Escuta)."));
  imprimirMenuSerial();
}

void loop() {
  // 1. Verifica continuamente o pino de interrupcao externa (INT)
  processarQuadrosRecebidos();

  // 2. Processa comandos do operador via Monitor Serial
  if (Serial.available() > 0) {
    char cmd = toupper(Serial.read());

    if (cmd == 'L') {
      executarAutotesteLoopback();
    }
    else if (cmd == 'S') {
      telemetriaObdAtiva = false;
      CAN0.setMode(MCP_LISTENONLY);
      Serial.println(F("\n[MODO] MCP2515 configurado em LISTEN-ONLY (Sniffer passivo 500 kbps)."));
    }
    else if (cmd == 'N') {
      telemetriaObdAtiva = false;
      CAN0.setMode(MCP_NORMAL);
      delay(10);
      byte msgIndustrial[4] = {0x01, 0xA0, 0xFF, 0x00};
      byte st = CAN0.sendMsgBuf(0x100, 0, 4, msgIndustrial);
      Serial.print(F("\n[MODO NORMAL] Envio de quadro ID 0x100 no barramento fisico -> "));
      Serial.println(st == CAN_OK ? F("ACK RECEBIDO (CAN_OK)!") : F("SEM ACK (verifique 2o no e 120 Ohms)."));
    }
    else if (cmd == 'O') {
      CAN0.setMode(MCP_NORMAL);
      telemetriaObdAtiva = !telemetriaObdAtiva;
      Serial.println(telemetriaObdAtiva
        ? F("\n[OBD-II] Varredura periodica de PIDs ATIVADA (500 kbps, Jumper J1 ABERTO)...")
        : F("\n[OBD-II] Varredura periodica PAUSADA."));
    }
  }

  // 3. Disparo ciclico nao-bloqueante de requisicoes OBD-II a cada 250 ms
  if (telemetriaObdAtiva && (millis() - ultimoDisparoObdMs >= 250)) {
    ultimoDisparoObdMs = millis();
    const uint8_t listaPids[3] = {PID_ROTACAO_MOTOR_RPM, PID_VELOCIDADE_KMH, PID_TEMP_ARREFECIMENTO};

    requisitarPidObd2(listaPids[indicePidAtual]);
    indicePidAtual = (indicePidAtual + 1) % 3;
  }
}

Projetos

Para expandir a leitura do barramento CAN e o diagnóstico veicular ou industrial com dashboards gráficos via Wi-Fi e acionamento remoto de cargas de potência, confira os projetos completos disponíveis no blog da RoboBuilders:

• Painel Web de Diagnóstico para ESP32: Arquitetura completa com servidor web embarcado em tempo real no ESP32, ideal para servir como base de um gateway CAN-para-Wi-Fi exibindo RPM, temperatura e logs de pacotes do MCP2515 diretamente na tela do celular ou computador.
• Painel Web para Placa ESP32 com 8 Relés de 30A (RB2553): Projeto prático de automação industrial de código aberto que pode ser integrado ao módulo MCP2515 para criar unidades remotas de acionamento de alta corrente comandadas via rede CAN 2.0B em chão de fábrica ou implementos agrícolas.

Conclusão

Neste manual técnico do Módulo CAN BUS MCP2515 TJA1050 OBD-II (RB0552), foram detalhados os parâmetros elétricos, construtivos e de programação indispensáveis para projetos confiáveis de comunicação industrial e automotiva:

• Especificações elétricas e arquitetura bipartida: Operação em conformidade com o padrão CAN V2.0B / ISO 11898-2 até $1\,\text{Mbps}$, combinando o controlador SPI MCP2515 (até $10\,\text{MHz}$, cristal de $8{,}000\,\text{MHz}$) com o transceptor diferencial TJA1050 alimentado estritamente em $5{,}0\,\text{VDC}$ ($4{,}75\,\text{V}$ a $5{,}25\,\text{V}$).
• Mapeamento de pinos e compatibilização de níveis lógicos: Identificação exata do barramento de 7 pinos (VCC, GND, CS, SO, SI, SCK, INT), ligação direta a placas de $5\,\text{V}$ (Arduino Uno/Mega) e uso obrigatório de conversor de nível lógico bidirecional ($3{,}3\,\text{V} \leftrightarrow 5{,}0\,\text{V}$) ao integrar com ESP32.
• Regras de cabeamento diferencial e terminação de $120\,\Omega$: Uso de par trançado entre CANH e CANL, verificação de resistência equivalente de $60\,\Omega$ na rede desenergizada e abertura obrigatória do jumper J1 ao acoplar o módulo à porta OBD-II (pinos 6 e 14) de veículos.
• Equacionamento temporal e diagnóstico prático: Cálculo de Time Quanta ($T_Q$) para $8\,\text{MHz}$, validação isolada de bancada via modo Loopback, inspeção segura em modo Listen-Only e decodificação de telemetria OBD-II em tempo real.

Seguindo rigorosamente o ajuste da frequência do cristal (MCP_8MHZ), as regras de terminação física do barramento e os cuidados de segurança veicular apresentados neste guia, o módulo MCP2515 + TJA1050 proporciona conectividade determinística e elevada robustez eletromagnética para instrumentação automotiva, robótica móvel e redes industriais.

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Módulo CAN BUS MCP2515 TJA1050 OBD-II: Manual Técnico Completo e eu ajudarei a encontrar a solução.

Enviar

O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.