Arduino personalizado para manter os botões do volante do CAN com o novo som do carro: 9 etapas (com imagens)

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

Decidi substituir o som do carro original no meu Volvo V70 -02 por um novo para poder desfrutar de coisas como mp3, bluetooth e viva-voz.

Meu carro tem alguns controles de volante para o som que eu gostaria de poder usar. Não esperava que isso fosse um problema porque existem vários adaptadores no mercado que deveriam ser compatíveis com o meu carro. No entanto, logo descobri que não eram! (Parece que os adaptadores para V70 podem ter problemas com -02 carros devido a um protocolo CAN ligeiramente diferente.)

Então, o que fazer? Manter o aparelho de som antigo? Viver uma vida com botões que não funcionam? Claro que não! Se não houver um adaptador funcionando no mercado, teremos que construir um!

Este instrutível pode ser aplicado (com algumas adaptações) a carros onde os botões do volante se comunicam através do barramento CAN.

Etapa 1: Descubra como enviar comandos para o estéreo

A primeira coisa que você deve fazer é descobrir que tipo de entrada remota o aparelho de som espera. Normalmente, os fabricantes não dizem isso e você provavelmente também não tem acesso a controles remotos funcionais para engenharia reversa.

A entrada remota do meu novo aparelho de som (Kenwood) consiste em um único fio e não consegui descobrir nenhuma informação sobre como funciona. No entanto, também possui um conector de 3,5 mm para entrada remota. Eu também não consegui descobrir nada sobre isso. Mas existem algumas informações sobre um conector de 3,5 mm para outras marcas, sugerindo que diferentes comandos são identificados pela aplicação de uma resistência específica entre a ponta e a manga (e opcionalmente entre o anel e a manga). Por exemplo. https://forum.arduino.cc/index.php?topic=230068.0. Então decidi tentar, equipado com uma placa de ensaio, um monte de resistores e um plugue de 3,5 mm conectado ao aparelho de som e conectado à placa de ensaio. Nada foi reconhecido no início, mas o aparelho de som tem um menu "modo de aprendizagem" e lá os comandos podem ser configurados com sucesso ao aplicar várias resistências. Sucesso!

No entanto, mais tarde descobri que cometi um erro aqui: nem todos os comandos que o aparelho de som parecia aprender realmente funcionariam. Por exemplo. 30 kOhm foi encontrado no modo de aprendizagem, mas não funcionou mais tarde e para alguns dos comandos que configurei a diferença de resistência era tão pequena que mais tarde o comando errado foi acionado.

Portanto, recomendo que você use uma placa de ensaio com resistores e botões de alternância para todos os comandos remotos que deseja controlar e teste se todos eles funcionarão.

Se o som do seu carro não pode receber entrada da mesma maneira, você terá que descobrir como ele funciona para poder adaptar esta solução. Se você não consegue descobrir, então você tem um problema.

Etapa 2: Descubra onde se conectar ao barramento CAN

Você precisa localizar um bom lugar para se conectar ao barramento CAN. Já que você está substituindo um aparelho de som antigo que se comunica por CAN, você deve conseguir encontrá-lo atrás do aparelho de som. O barramento CAN consiste em um par de fios trançados (CAN-L e CAN_H). Consulte um diagrama de fiação do seu carro para ter certeza.

Etapa 3: Engenharia reversa de mensagens CAN

A menos que o Google possa dizer quais mensagens CAN você deve ouvir, você precisará se conectar ao barramento CAN e fazer alguma engenharia reversa. Usei um Arduino Uno e um escudo CAN. (Você realmente não precisa do escudo CAN, como verá mais tarde, pode usar alguns componentes baratos em uma placa de ensaio.)

Consulte o Google para descobrir qual taxa de transmissão você deve usar ao se conectar ao seu carro. (Normalmente, você descobrirá que existe uma rede CAN de alta e uma de baixa velocidade. Você está se conectando à rede de baixa velocidade.)

Você também precisará programar o Arduino para registrar todas as mensagens CAN na interface serial para que possa salvá-las em um arquivo de registro em seu computador. O Arduino IDE padrão não salvará dados em um arquivo de log, mas você pode usar, por exemplo, Em vez disso, Putty.

Antes de começar a escrever seu programa, você precisa instalar a biblioteca CAN_BUS_Shield.

Aqui estão alguns pseudocódigos para ajudá-lo a começar com seu programa:

configurar()

{conexão serial init biblioteca CAN init} loop () {se mensagem CAN for recebida {ler entrada de log de formato de mensagem CAN gravar entrada de log para serial}}

Dicas:

Você usará uma instância da classe MCP_CAN para acessar a funcionalidade da biblioteca CAN:

MCP_CAN m_can;

Init CAN:

enquanto (m_can.begin ()! = CAN_OK)

{atraso (1000); }

Verifique e leia as mensagens CAN:

while (m_can.checkReceive () == CAN_MSGAVAIL)

{// Obter ID CAN, comprimento da mensagem e dados da mensagem m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Faça algo com os dados da mensagem aqui}

Se precisar de mais ajuda, você poderá encontrar um link para meu programa em uma etapa posterior. A biblioteca de blindagem CAN também inclui um exemplo. Ou verifique o instrutível de mviljoen2 que inclui uma etapa semelhante.

Primeiro, você precisará de um arquivo de referência para ajudá-lo a filtrar os dados. Mude a ignição para o modo de rádio e registre tudo por alguns minutos sem tocar em nenhum botão.

Em seguida, para cada um dos botões, inicie o registro, pressione o botão e pare o registro.

Quando terminar, você precisa filtrar tudo o que está em seu registro de referência de seus registros de botão para encontrar seus candidatos. Descobri que ainda havia muitas mensagens deixadas, então fiz mais logs e solicitei que "os candidatos para o comando A devem estar em todos os arquivos de botão A e em nenhum dos arquivos de referência". Isso me deixou com apenas algumas possibilidades para tentar.

Os logs conterão muitas mensagens, então você precisará escrever algum programa para isso ou possivelmente usar o Excel. (Usei um programa com condições muito codificadas para minhas necessidades, então não posso oferecer um programa que você possa usar.)

Um aviso: você não pode ter certeza de que um botão sempre produzirá uma mensagem idêntica. Alguns dos bits podem conter contadores de incremento, etc. (Você pode, no entanto, deixar que o id da mensagem seja o mesmo.)

Se acontecer de você ter um Volvo V70 -02, isto é o que você procura:

• ID da mensagem: 0x0400066Byte0: 0x00, 0x40, 0x80 ou 0xc0 (não importa)
• Byte1: 0x00 (não importa)
• Byte2: 0x00 (não importa)
• Byte3: 0x00-0x07 (não importa)
• Byte4: 0x1f (não importa)
• Byte5: 0x40 (não importa)
• Byte6: 0x40 (não importa)
• Byte7: Identificador do botão: 0x77 = aumentar o volume, 0x7b = diminuir o volume, 0x7d = próxima faixa, 0x7e = faixa anterior.

Quando você acredita que encontrou os comandos, pode ser uma boa ideia modificar o programa para que ele registre apenas as mensagens interessantes. Observe a janela de registro serial enquanto pressiona os botões para verificar se identificou as mensagens corretas.

Etapa 4: O protótipo de hardware

Seu hardware precisa ser capaz de:

1. Identificar comandos recebidos no barramento CAN
2. Envie comandos em outro formato para o aparelho de som

Se você tiver espaço suficiente, pode usar um Arduino e um escudo CAN para a primeira parte e conectar algum hardware adicional para a segunda. No entanto, existem algumas desvantagens:

• Custo do escudo CAN
• Tamanho
• A fonte de alimentação do Arduino não ficará feliz se for conectada diretamente aos seus carros de 12V (provavelmente funcionará, mas sua vida útil provavelmente será encurtada).

Então, em vez disso, usei o seguinte:

• Atmega 328, o "cérebro Arduino". (Existem algumas variantes, obtenha uma que seja igual à do Arduino Uno. Você pode comprá-la com ou sem o carregador de inicialização do Arduino.)
• Cristal de 16 MHz + capacitores para sinal de clock.
• Transceptor MCP2551 CAN.
• Controlador MCP2515 CAN.
• TSR1-2450, converte 6,5-36V em 5V. (Não usado no protótipo porque o software não se preocupa com a fonte de alimentação.)
• Chave CD4066B que será usada ao enviar comandos para o estéreo.
• Alguns resistores. (Os valores podem ser encontrados nos esquemas Eagle em uma etapa posterior.)

Uma coisa boa com essa configuração é que ela é totalmente compatível com o Arduino e a biblioteca de escudo CAN.

Se você deseja manipular mais de quatro botões, pode considerar o uso de algo diferente do CD4066B. O CD4066B pode ser descrito como quatro interruptores em um, cada um controlado por um dos pinos Atmegas GPIO. Para cada chave há um resistor conectado que pode ser usado para controlar a resistência usada como entrada para o estéreo. Portanto, isso pode ser facilmente usado para enviar quatro comandos diferentes. Se eles forem combinados, valores adicionais de resistência podem ser obtidos. É aqui que entra o erro que mencionei anteriormente. Tenho quatro botões, mas planejei implementar dois deles como pressionamento longo e curto para me dar seis comandos diferentes. Mas no final descobri que não conseguia encontrar uma combinação de resistores que me desse seis combinações de trabalho. Provavelmente seria possível conectar um sinal de saída analógica ao estéreo (ponta de 3,5 mm). (Observe que o Atmega não possui pinos de saída analógica verdadeira, portanto, será necessário algum hardware adicional.)

Para fins de teste, também fiz um simulador simples de "carro e estéreo" para conectar ao meu protótipo. Isso torna a depuração mais fácil e, a menos que você goste de sentar no carro e programar, posso recomendar isso.

O protótipo é ilustrado pelo breadboard inferior na imagem. Para fonte de alimentação, programação e registro serial, ele é conectado a um Arduino Uno de onde o chip Atmega foi removido.

A placa de ensaio superior é o simulador de carro + estéreo que será usado para o teste inicial do protótipo.

O protótipo + simulador deve funcionar assim:

• Pressione um dos botões de interruptor na placa do simulador. (Esses são os botões do volante.)
• Quando o programa simulador detecta o pressionamento de um botão, ele envia a mensagem CAN correspondente a cada 70 ms, desde que o botão seja pressionado. (Porque os registros que fiz anteriormente indicavam que é assim que funciona no meu carro.) Ele também enviará muitas mensagens CAN "inúteis" para simular outro tráfego no ônibus.
• As mensagens CAN são enviadas no barramento CAN.
• As mensagens CAN são recebidas pelo protótipo.
• O MCP2515 lança todas as mensagens não relacionadas com base no ID da mensagem.
• Quando o MCP2515 recebe uma mensagem que deve ser tratada irá indicar que tem uma mensagem enfileirada.
• O Atmega irá ler a mensagem e decidir qual botão deve ser considerado ativo.
• O Atmega também acompanhará quando a última mensagem foi recebida, após um certo tempo o botão será considerado liberado. (As mensagens CAN indicam apenas que um botão está pressionado, não que ele foi pressionado ou solto.)
• Se um botão for considerado ativo, um ou mais interruptores no CD4066B serão ativados.
• O simulador (agora atuando como seu estéreo) detectará que uma resistência é aplicada entre a ponta e a manga. (A ponta é conectada a 3,3V e através de um resistor a um pino de entrada analógica. Quando nenhum comando estiver ativo este pino lerá 3,3V, quando um comando estiver ativo o valor ficará mais baixo e identificará o comando.
• Enquanto um comando estiver ativo, o led correspondente também será ativado. (Há seis leds porque planejei usar diferentes pressionamentos longos / curtos para dois dos meus botões.)

Para obter mais detalhes sobre o hardware do protótipo, consulte os esquemas do Eagle em uma etapa posterior.

Detalhes adicionais sobre o hardware da placa do simulador:

• Cristal de 16 MHz
• Capacitores de 22 pF
• Os resistores de LED devem ser selecionados com base nas propriedades do LED
• Resistor conectado a A7 e 3,3 V, selecione, por exemplo, 2kOhm (não crítico).
• Os resistores conectados a MCP2551 e MCP2515 são pull-up / pull-down. Selecione, por exemplo 10 kOhm.

(Ou você pode usar o escudo CAN para a "parte CAN" do simulador, se preferir.)

É importante que você saiba como os pinos do Atmega são mapeados para os pinos do Arduino ao projetar o hardware.

(Não conecte nenhum leds diretamente ao CD 4066B, ele só consegue lidar com uma corrente baixa. Eu tentei fazer isso quando testei a saída pela primeira vez e o chip se tornou inútil. A coisa boa é que comprei alguns deles só porque são tão baratos.)

Etapa 5: Programação do fusível

Talvez você tenha notado na etapa anterior que o protótipo não possui componentes separados para gerar o sinal de clock para o MCP2515. Isso porque já existe um cristal de 16 MHz usado como sinal de clock do Atmega que podemos usar. Mas não podemos simplesmente conectá-lo diretamente ao MCP2515 e, por padrão, não há sinal de saída de clock no Atmega.

(Se preferir, você pode pular esta etapa e adicionar o hardware de relógio extra.)

No entanto, podemos usar algo chamado "programação de fusíveis" para habilitar um sinal de clock out em um dos pinos GPIO.

Primeiro, você precisará localizar um arquivo chamado "boards.txt" usado pelo seu IDE Arduino. Você precisará copiar a entrada para Arduino Uno, dar a ela um novo nome e alterar o valor para low_fuses.

Minha nova placa é parecida com esta:

############################################################### ############# Com base no Arduino Uno # Mudanças: # low_fuses mudou de 0xff para 0xbf para habilitar 16 MHz clock # out em Atmega PB0 / pino 14 = Arduino D8

clkuno.name = Clock out (Arduino Uno)

clkuno.upload.protocol = arduino clkuno.upload.maximum_size = 32256 clkuno.upload.speed = 115200 clkuno.bootloader.low_fuses = 0xbf clkuno.bootloader.high_fuses = 0xde clkuno.bootunokk.bootloader.file = optiboot_atmega328.hex clkuno.bootloader.unlock_bits = 0xff clkuno.bootloader.lock_bits = 0xcf clkuno.build.mcu = atmega328p clkuno.build.f_cpu = 16000000L clkbuilduno.varinokiant = padrão

##############################################################

Observe que o clock out é ativado definindo seu bit de controle para 0.

Depois de criar a nova placa no arquivo de configuração de placas, você terá que gravar um novo carregador de boot no Atmega. Existem várias maneiras de fazer isso, usei o método descrito em

Depois de fazer isso, lembre-se de selecionar seu novo tipo de placa e não o Arduino Uno ao fazer upload de um programa para o Atmega.

Etapa 6: o software

É hora de tornar o hardware burro mais inteligente adicionando um pouco de software.

Aqui estão alguns pseudocódigos para o protótipo:

lastReceivedTime = 0

lastReceivedCmd = nenhum cmdTimeout = 100 setup () {habilitar watchdog configurar pinos D4-D7 como pinos de saída init Configuração CAN filtro CAN} loop () {reset watchdog if (mensagem CAN for recebida) {para cada comando de botão {se mensagem CAN pertencer a o comando do botão {lastReceivedTime = now lastReceivedCmd = cmd}}} if now> lastReceivedTime + cmdTimeout {lastReceivedCmd = none} para cada comando do botão {if lastReceivedCmd é o comando do botão {set command pin output = on} else {set command pin output = off }}}

cmdTimeout decide quanto tempo devemos esperar antes de considerar o último botão ativo liberado. Como os comandos de mensagem do botão CAN são enviados aproximadamente a cada 70 ms, ele precisa ser maior do que com alguma margem. Mas se for muito grande, haverá uma experiência de atraso. Portanto, 100 ms parece um bom candidato.

Mas o que é um cão de guarda? É um pequeno recurso de hardware útil que pode nos salvar em caso de travamento. Imagine que temos um bug que faz com que o programa trave enquanto o comando de aumentar o volume está ativo. Então acabaríamos com o aparelho de som no volume máximo! Mas se o watchdog não for zerado para o tempo específico, ele decidirá que algo inesperado aconteceu e simplesmente emitirá um reset.

void setup ()

{// permitir no máximo 250 ms para o loop wdt_enable (WDTO_250MS); // outras coisas de inicialização} void loop () {wdt_reset (); // Fazer coisas }

PODE filtrar? Bem, você pode configurar o controlador CAN para descartar todas as mensagens que não combinam com o filtro para que o software não perca tempo com mensagens que não nos importam.

máscara longa sem sinal = 0x1fffffff; // Inclui todos os 29 bits de cabeçalho na máscara

filtro longo sem sinalId = 0x0400066; // Só nos importamos com esta mensagem CAN id m_can.init_Mask (0, CAN_EXTID, máscara); // Máscara 0 se aplica ao filtro 0-1 m_can.init_Mask (1, CAN_EXTID, máscara); // Máscara 1 se aplica ao filtro 2-5 m_can.init_Filt (0, CAN_EXTID, filterId); m_can.init_Filt (1, CAN_EXTID, filterId); m_can.init_Filt (2, CAN_EXTID, filterId); m_can.init_Filt (3, CAN_EXTID, filterId); m_can.init_Filt (4, CAN_EXTID, filterId); m_can.init_Filt (5, CAN_EXTID, filterId);

Verifique o código da biblioteca CAN e a documentação do controlador CAN para obter mais detalhes sobre como configurar o filtro + máscara.

Você também pode configurar o controlador CAN para gerar uma interrupção quando uma mensagem (que não é filtrada) for recebida. (Não incluído no exemplo acima, mas há algum código para ele no meu programa.) Nesse caso, ele realmente não adiciona nenhum valor e pode ser confuso se você não estiver acostumado a programar.

Então esse foi o software protótipo em resumo. Mas também precisamos de algum código para a placa do simulador:

lastSentTime = 0

minDelayTime = 70 setup () {configure os pinos A0-A5 como pinos de saída, configure os pinos D4-D7 como pinos de entrada com pullup interno. init CAN} loop () {enviar "lixo" pode msg definir activeButton = none para cada botão {se o botão for pressionado {definir activeButton = botão}} if activeButton! = none {if now> lastSentTime + minDelayTime {comando do botão enviar pode mensagem } definir lastSentTime = agora} inval = ler pino A7 foreach (cmd) {if (min <inval <max) {led on} else {led off}} esperar por 1 ms}

Isso enviará continuamente mensagens CAN "indesejadas" aproximadamente a cada ms e, enquanto um botão for pressionado, o comando correspondente a cada 70 ms.

Você pode precisar registrar a entrada no pino A7 enquanto pressiona os diferentes botões para descobrir os valores adequados para as variáveis mínimas e máximas pertencentes a cada botão. (Ou você pode calculá-lo, mas realmente ler a entrada fornecerá valores mais precisos.)

Você precisa ter um pouco de cuidado ao programar os modos de pin. Se você acidentalmente definir os pinos destinados a usar pullup interno como pinos de saída, em vez disso, você criará um atalho potencial que danificará seu Arduino quando definir a saída alta.

Se você quiser verificar meus programas, eles podem ser baixados aqui:

• Programa de registro de mensagens CAN
• Programa para a placa simuladora
• Programa para protótipo / placa final

Você deve estar ciente de que esses programas não correspondem realmente ao pseudo código aqui, eles contêm muitas coisas "extras" que não são realmente necessárias e se você não estiver familiarizado com a programação orientada a objetos, provavelmente pode ser um pouco difícil de ler.

Etapa 7: o hardware final

Quando estiver satisfeito com seu programa (lembre-se de testar o protótipo no carro após o teste final com a placa do simulador), é hora de construir o hardware real.

Você tem três opções aqui:

• Rápido e sujo - solde tudo junto em uma placa de protótipo PCB.
• Hardcore DIY - crie seu próprio PCB.
• A maneira preguiçosa - peça um PCB profissional para soldar os componentes.

Se você não tem pressa, posso recomendar a última opção. Se você só precisa de um pequeno PCB como este, é muito barato encomendá-lo da China. (E então você provavelmente obterá dez peças ou mais para que possa se dar ao luxo de alguns erros de soldagem.)

Para solicitar PCBs, você precisará enviar seu projeto no formato Gerber. Existem vários softwares para isso. Eu usei o Eagle, que posso recomendar. Você pode esperar algumas horas para aprender, mas funciona bem. Para pequenas placas como essa, você pode usá-lo gratuitamente.

Tenha cuidado ao fazer o design. Você não quer esperar quatro semanas pela entrega apenas para descobrir que fez algo errado.

(Se você tiver boas habilidades de soldagem, pode projetar para componentes montados em superfície e obter um adaptador realmente pequeno. Eu não fiz.)

Em seguida, faça o pedido em, por exemplo https://www.seeedstudio.com/fusion_pcb.html. Siga as instruções sobre como gerar os arquivos Gerber a partir de seu projeto. Você também pode obter uma visualização do resultado para garantir que está tudo bem.

(No final, tive que selecionar outros resistores para R4-R7 além dos listados na imagem esquemática. Em vez disso, usei 2k, 4,7k, 6,8k e 14,7k.)

E lembre-se - não confunda a numeração de pinos do Atmega com a numeração de pinos do Arduino!

Eu recomendo que você não solde o chip Atmega diretamente, mas use um soquete. Em seguida, você pode removê-lo facilmente caso precise reprogramá-lo.

Etapa 8: montagem do carro

Agora, a parte mais divertida - monte-o em seu carro e comece a usá-lo! (Depois de ter feito / comprado uma caixa para ele.)

Se você já testou totalmente o protótipo em seu carro, tudo deve funcionar perfeitamente.

(Como mencionei anteriormente, não o fiz, então tive que substituir alguns resistores e fazer algumas mudanças em meu programa.)

Considere também se você deve montá-lo atrás do aparelho de som ou em outro lugar. Encontrei um bom lugar acima do meu porta-luvas, onde posso alcançá-lo de dentro do porta-luvas sem desmontar nada. Isso pode ser útil se eu decidir atualizá-lo mais tarde.

Finalmente meus botões estão funcionando novamente! Como eu poderia sobreviver por dois meses sem eles?

Etapa 9: melhorias futuras

Como mencionei, se eu fizer uma versão 2.0 deste, irei substituir o 4066B por outro (provavelmente um potenciômetro digital) para maior flexibilidade.

Também há muitas outras coisas que você pode fazer. Por exemplo. adicione um módulo bluetooth e faça um aplicativo de controle remoto para o seu telefone. Ou um módulo GPS, então quando você estiver perto de casa, você pode aumentar o volume automaticamente e enviar a mensagem CAN "windows down" para que todos os seus vizinhos possam desfrutar de sua música maravilhosa.