Arduino personalizado para mantener los botones del volante CAN con el nuevo estéreo del automóvil: 9 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

Decidí reemplazar el estéreo del auto original en mi Volvo V70 -02 con un estéreo nuevo para poder disfrutar de cosas como mp3, bluetooth y manos libres.

Mi automóvil tiene algunos controles en el volante para el estéreo que me gustaría poder seguir usando. No esperaba que eso fuera un problema porque hay varios adaptadores en el mercado que se supone que son compatibles con mi automóvil. Sin embargo, pronto descubrí que no lo eran. (Parece que los adaptadores para V70 pueden tener problemas con los coches -02 debido a un protocolo CAN ligeramente diferente).

Entonces, ¿qué hacer entonces? ¿Quédate con el viejo estéreo? ¿Vive una vida con botones que no funcionan? ¡Por supuesto no! Si no hay un adaptador que funcione en el mercado, ¡tendremos que construir uno!

Este instructable se puede aplicar (con algunas adaptaciones) a los automóviles donde los botones del volante se comunican a través del bus CAN.

Paso 1: Descubra cómo enviar comandos al estéreo

Lo primero que debe hacer es averiguar qué tipo de entrada remota espera el estéreo. Por lo general, los fabricantes no le dirán eso y probablemente tampoco tenga acceso a controles remotos que funcionen para la ingeniería inversa.

El control remoto de mi nuevo estéreo (Kenwood) consta de un solo cable y no he podido encontrar ninguna información sobre cómo funciona. Sin embargo, también tiene un conector de 3,5 mm para entrada remota. Tampoco pude averiguar nada sobre eso. Pero hay alguna información sobre un conector de 3,5 mm para otras marcas que sugiere que los diferentes comandos se identifican aplicando una resistencia específica entre punta y manguito (y opcionalmente entre anillo y manguito). P.ej. https://forum.arduino.cc/index.php?topic=230068.0. Así que decidí intentarlo, equipado con una placa de pruebas, un montón de resistencias y un enchufe de 3,5 mm enchufado al estéreo y conectado a la placa de pruebas. No se reconoció nada al principio, pero el estéreo tiene un menú de "modo de aprendizaje" y allí los comandos se pueden configurar con éxito aplicando varias resistencias. ¡Éxito!

Sin embargo, más tarde descubrí que cometí un error aquí: no todos los comandos que el estéreo parecía aprender realmente funcionarían. P.ej. Se encontraron 30 kOhmios en el modo de aprendizaje, pero no funcionaron más tarde y para algunos de los comandos que configuré, la diferencia de resistencia fue tan pequeña que luego se activó el comando incorrecto.

Por lo tanto, le recomiendo que use una placa de pruebas con resistencias y botones de interruptor para todos los comandos remotos que desea manejar y que realmente pruebe que todos funcionarán.

Si el estéreo de su automóvil no puede recibir la entrada de la misma manera, tendrá que averiguar cómo funciona para poder adaptar esta solución. Si no puede averiguarlo, entonces tiene un problema.

Paso 2: averigüe dónde conectarse al bus CAN

Necesita ubicar un buen lugar para conectarse al bus CAN. Dado que está reemplazando un estéreo antiguo que se comunica a través de CAN, debería poder encontrarlo detrás del estéreo. El bus CAN consta de un par de cables trenzados (CAN-L y CAN_H). Consulte un diagrama de cableado de su automóvil para estar seguro.

Paso 3: Ingeniería inversa de mensajes CAN

A menos que Google pueda decirle qué mensajes CAN debe escuchar, deberá conectarse al bus CAN y realizar ingeniería inversa. Usé un Arduino Uno y un escudo CAN. (Realmente no necesita el escudo CAN, como verá más adelante, puede usar algunos componentes baratos en una placa de pruebas).

Consulte a Google para averiguar qué velocidad en baudios debe usar al conectarse a su automóvil. (Por lo general, encontrará que hay una red CAN de alta y baja velocidad. Se está conectando a la red de baja velocidad).

También necesitará programar el Arduino para registrar todos los mensajes CAN a través de la interfaz serial para que pueda guardarlos en un archivo de registro en su computadora. El IDE estándar de Arduino no guardará datos en un archivo de registro, pero puede usar, por ejemplo, Masilla en su lugar.

Antes de comenzar a escribir su programa, debe instalar la biblioteca CAN_BUS_Shield.

Aquí hay algunos pseudocódigos para ayudarlo a comenzar con su programa:

configuración()

{init conexión serial init biblioteca CAN} loop () {si se recibe el mensaje CAN {leer entrada de registro de formato de mensaje CAN escribir entrada de registro en serial}}

Sugerencias:

Utilizará una instancia de la clase MCP_CAN para acceder a la funcionalidad de la biblioteca CAN:

MCP_CAN m_can;

INICI PUEDE:

while (m_can.begin ()! = CAN_OK)

{retraso (1000); }

Compruebe y lea los mensajes CAN:

while (m_can.checkReceive () == CAN_MSGAVAIL)

{// Obtener el ID de CAN, la longitud del mensaje y los datos del mensaje m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Haz algo con los datos del mensaje aquí}

Si necesita más ayuda, puede encontrar un enlace a mi programa en un paso posterior. La biblioteca de blindaje CAN también incluye un ejemplo. O consulte el instructable de mviljoen2 que incluye un paso similar.

Primero, necesitará un archivo de referencia para ayudarlo a filtrar los datos. Cambie el encendido al modo de radio y registre todo durante un par de minutos sin tocar ningún botón.

Luego, para cada uno de los botones, comience a registrar, presione el botón y deje de registrar.

Cuando haya terminado, debe filtrar todo lo que está en su registro de referencia de sus registros de botones para encontrar a sus candidatos. Descubrí que todavía quedaban muchos mensajes, así que hice más registros y luego solicité que "los candidatos para el comando A deben estar en todos los archivos de botón A y en ninguno de los archivos de referencia". Eso me dejó solo con unas pocas posibilidades para intentarlo.

Los registros contendrán muchos mensajes, por lo que deberá escribir algún programa para esto o posiblemente usar Excel. (Usé un programa con condiciones codificadas muy rígidas para mis necesidades, así que me temo que no puedo ofrecer un programa que pueda usar).

Una advertencia: no puede estar seguro de que un botón siempre produzca un mensaje idéntico. Algunos de los bits pueden contener contadores incrementales, etc. (Sin embargo, puede excepto que la identificación del mensaje sea la misma).

Si tiene un Volvo V70 -02, esto es lo que busca:

• ID de mensaje: 0x0400066 Byte0: 0x00, 0x40, 0x80 o 0xc0 (no importa)
• Byte1: 0x00 (no importa)
• Byte2: 0x00 (no importa)
• Byte3: 0x00-0x07 (no importa)
• Byte4: 0x1f (no importa)
• Byte5: 0x40 (no importa)
• Byte6: 0x40 (no importa)
• Byte7: Identificador de botón: 0x77 = subir volumen, 0x7b = bajar volumen, 0x7d = pista siguiente, 0x7e = pista anterior.

Cuando crea que ha encontrado los comandos, puede ser una buena idea modificar el programa para que solo registre los mensajes interesantes. Mire la ventana de registro en serie mientras presiona los botones para verificar que haya identificado los mensajes correctos.

Paso 4: el prototipo de hardware

Su hardware debe poder:

1. Identificar los comandos recibidos en el bus CAN
2. Envía comandos en otro formato al estéreo

Si tiene suficiente espacio, puede usar un Arduino y un escudo CAN para la primera parte y adjuntar algún hardware adicional para la segunda. Sin embargo, hay algunos inconvenientes:

• Costo del escudo CAN
• Tamaño
• La fuente de alimentación Arduino no estará contenta si está conectada directamente a los 12 V de su automóvil (probablemente funcionará, pero es probable que su vida útil se acorte).

Entonces, en su lugar, usé lo siguiente:

• Atmega 328, el "cerebro Arduino". (Hay algunas variantes, obtenga una que sea igual a la de Arduino Uno. Puede comprarlo con o sin cargador de arranque Arduino).
• Cristal de 16 MHz + condensadores para señal de reloj.
• Transceptor CAN MCP2551.
• Controlador CAN MCP2515.
• TSR1-2450, convierte 6.5-36V a 5V. (No se utiliza en el prototipo porque el software no se preocupará por la fuente de alimentación).
• Conmutador CD4066B que se utilizará al enviar comandos al estéreo.
• Un par de resistencias. (Los valores se pueden encontrar en los esquemas de Eagle en un paso posterior).

Una cosa buena con esta configuración es que es totalmente compatible con Arduino y la biblioteca de escudo CAN.

Si desea manejar más de cuatro botones, es posible que desee considerar usar algo más que el CD4066B. El CD4066B se puede describir como cuatro interruptores en uno, cada uno controlado por uno de los pines GPIO de Atmegas. A cada interruptor hay una resistencia conectada que se puede usar para controlar la resistencia que se usa como entrada al estéreo. Por lo tanto, esto se puede usar fácilmente para enviar cuatro comandos diferentes. Si se combinan, se pueden obtener valores de resistencia adicionales. Aquí es donde entra el error que mencioné anteriormente. Tengo cuatro botones, pero planeé implementar dos de ellos con una presión larga y corta para darme seis comandos diferentes. Pero al final descubrí que no podía encontrar una combinación de resistencias que me diera seis combinaciones de trabajo. Probablemente sería posible conectar una señal de salida analógica al estéreo (punta de 3,5 mm) en su lugar. (Tenga en cuenta que el Atmega no tiene pines de salida analógicos verdaderos, por lo que se necesitaría algo de hardware adicional).

Con fines de prueba, también hice un simulador simple de "automóvil y estéreo" para conectarlo a mi prototipo. Facilita la depuración y, a menos que le guste sentarse en su automóvil y programar, puedo recomendarlo.

El prototipo se ilustra en la placa inferior de la imagen. Para la fuente de alimentación, la programación y el registro en serie, se adjunta a un Arduino Uno donde se ha eliminado el chip Atmega.

La placa superior es el simulador de coche + estéreo que se utilizará para la prueba inicial del prototipo.

El prototipo + simulador está diseñado para funcionar así:

• Presione uno de los botones del interruptor en el tablero del simulador. (Esos son los botones del volante).
• Cuando el programa del simulador detecta que se presiona un botón, enviará el mensaje CAN correspondiente cada 70 ms mientras se presione el botón. (Porque los registros que tomé anteriormente indicaron que así es como funciona en mi automóvil). También enviará muchos mensajes CAN "basura" para simular otro tráfico en el autobús.
• Los mensajes CAN se envían por el bus CAN.
• Los mensajes CAN son recibidos por el prototipo.
• El MCP2515 arroja todos los mensajes no relacionados según la identificación del mensaje.
• Cuando el MCP2515 recibe un mensaje que debe manejarse, indicará que tiene un mensaje en cola.
• El Atmega leerá el mensaje y decidirá qué botón debe considerarse activo.
• El Atmega también hará un seguimiento de cuándo se recibió el último mensaje, después de un cierto tiempo el botón se considerará liberado. (Los mensajes CAN solo indican que un botón está presionado, no que se haya presionado o liberado).
• Si un botón se considera activo, se activarán uno o más interruptores en el CD4066B.
• El simulador (que ahora actúa como su estéreo) detectará que se aplica una resistencia entre la punta y la manga. (La punta está conectada a 3.3V ya través de una resistencia a un pin de entrada analógica. Cuando no hay ningún comando activo, este pin leerá 3.3V, cuando un comando está activo, el valor bajará e identificará el comando.
• Mientras un mando esté activo también se activará el led correspondiente. (Hay seis leds porque planeé usar diferentes pulsaciones largas / cortas para dos de mis botones).

Para obtener más detalles sobre el hardware prototipo, consulte los esquemas de Eagle en un paso posterior.

Detalles adicionales sobre el hardware de la placa del simulador:

• Cristal de 16 MHz
• Condensadores de 22 pF
• Las resistencias LED deben seleccionarse en función de las propiedades de los LED
• Resistencia conectada a A7 y 3.3V, seleccione p. Ej. 2kOhm (no crítico).
• Las resistencias conectadas a MCP2551 y MCP2515 son pull-up / pull-down. Seleccione, p. Ej. 10 kOhm.

(O puede usar el escudo CAN para la "parte CAN" del simulador si lo prefiere).

Es importante que sepa cómo se asignan los pines Atmega a los pines Arduino cuando diseña el hardware.

(No conecte ningún LED directamente al CD 4066B, solo puede manejar una corriente baja. Lo intenté cuando probé por primera vez la salida y el chip se volvió inútil. Lo bueno es que había comprado un par de ellos solo porque son tan baratos.)

Paso 5: Programación de fusibles

Quizás haya notado en el paso anterior que el prototipo no tiene componentes separados para generar la señal de reloj al MCP2515. Eso es porque ya hay un cristal de 16 MHz usado como señal de reloj Atmega que podemos usar. Pero no podemos simplemente conectarlo directamente al MCP2515 y, por defecto, no hay señal de reloj en el Atmega.

(Si lo prefiere, puede omitir este paso y agregar el hardware de reloj adicional).

Sin embargo, podemos usar algo llamado "programación de fusibles" para habilitar una señal de salida en uno de los pines GPIO.

Primero necesitará ubicar un archivo llamado "boards.txt" usado por su IDE de Arduino. Deberá copiar la entrada para Arduino Uno, darle un nuevo nombre y cambiar el valor de low_fuses.

Mi nueva placa se ve así:

################################################ ############ # Basado en Arduino Uno # Cambios: # low_fuses cambió de 0xff a 0xbf para habilitar la salida de reloj de 16 MHz # en Atmega PB0 / pin 14 = Arduino D8

clkuno.name = Salida (Arduino Uno)

clkuno.upload..bootloader.file = optiboot_atmega328.hex clkuno.bootloader.unlock_bits = 0xff clkuno.bootloader.lock_bits = 0xcf clkuno.build.mcu = atmega328p clkuno.build.f_cpu = 16000000L clkuno.builduno.buildino.

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

Tenga en cuenta que el reloj de salida se activa estableciendo su bit de control en 0.

Cuando haya creado la nueva placa en el archivo de configuración de placas, tendrá que grabar un nuevo cargador de arranque en Atmega. Hay varias formas de hacer esto, utilicé el método descrito en

Después de haber hecho esto, recuerde seleccionar su nuevo tipo de placa y no el Arduino Uno cuando cargue un programa en Atmega.

Paso 6: el software

Es hora de hacer que el hardware tonto sea inteligente agregando algún software.

Aquí hay algunos pseudocódigos para el prototipo:

lastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 setup () {habilitar watchdog configurar pines D4-D7 como pines de salida init CAN setup CAN filter} loop () {reiniciar watchdog si (se recibe un mensaje CAN) {para cada comando de botón {si el mensaje CAN pertenece a el comando de botón {lastReceivedTime = ahora lastReceivedCmd = cmd}}} si ahora> lastReceivedTime + cmdTimeout {lastReceivedCmd = none} para cada comando de botón {si lastReceivedCmd es el comando de botón {set command pin output = on} else {set command pin output = off }}}

cmdTimeout decide cuánto tiempo debemos esperar antes de considerar el último botón activo liberado. Debido a que los comandos de mensaje CAN del botón se envían aproximadamente cada 70 ms, debe ser más grande que eso con cierto margen. Pero si es demasiado grande, habrá una experiencia de retraso. Entonces 100 ms parece un buen candidato.

Pero, ¿qué es un perro guardián? Es una pequeña característica útil del hardware que puede salvarnos en caso de un bloqueo. Imagine que tenemos un error que hace que el programa se bloquee mientras el comando de aumento de volumen está activo. ¡Entonces terminaríamos con el estéreo al máximo volumen! Pero si el perro guardián no se reinicia durante el tiempo específico, decidirá que ha sucedido algo inesperado y simplemente emitirá un reinicio.

configuración vacía ()

{// permite un máximo de 250 ms para el bucle wdt_enable (WDTO_250MS); // otras cosas de inicio} void loop () {wdt_reset (); // hacer cosas }

¿PUEDE filtrar? Bueno, puede configurar el controlador CAN para descartar todos los mensajes que no coincidan con el filtro para que el software no tenga que perder tiempo en mensajes que no nos importan.

máscara larga sin firmar = 0x1fffffff; // Incluir los 29 bits de encabezado en la máscara

ID de filtro largo sin firmar = 0x0400066; // Solo nos importa este ID de mensaje CAN m_can.init_Mask (0, CAN_EXTID, mask); // La máscara 0 se aplica al filtro 0-1 m_can.init_Mask (1, CAN_EXTID, mask); // La máscara 1 se aplica al 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);

Consulte el código de la biblioteca CAN y la documentación del controlador CAN para obtener más detalles sobre cómo configurar el filtro + la máscara.

También puede configurar el controlador CAN para generar una interrupción cuando se recibe un mensaje (que no se filtra). (No se incluye en el ejemplo anterior, pero hay algún código en mi programa). En este caso, realmente no agrega ningún valor y puede ser confuso si no está acostumbrado a programar.

Así que ese fue el prototipo de software en resumen. Pero también necesitamos algo de código para la placa del simulador:

lastSentTime = 0

minDelayTime = 70 setup () {configurar pines A0-A5 como pines de salida configurar pines D4-D7 como pines de entrada con pullup interno. init CAN} loop () {enviar "basura" can msg set activeButton = none para cada botón {si se presiona el botón {set activeButton = button}} if activeButton! = none {if now> lastSentTime + minDelayTime {enviar el comando del botón puede enviar mensaje } set lastSentTime = now} inval = read pin A7 foreach (cmd) {if (min <inval <max) {led on} else {led off}} espera 1 ms}

Esto enviará continuamente mensajes CAN "basura" aproximadamente cada ms y mientras se presiona un botón el comando correspondiente cada 70 ms.

Es posible que deba registrar la entrada en el pin A7 mientras presiona los diferentes botones para encontrar los valores adecuados para las variables mínimas y máximas que pertenecen a cada botón. (O puede calcularlo, pero leer la entrada le dará valores más precisos).

Debe tener un poco de cuidado al programar los modos de pin. Si accidentalmente configura los pines destinados a usar pullup interno como pines de salida, entonces creará un atajo potencial que dañará su Arduino cuando configure la salida alta.

Si quieres consultar mis programas, puedes descargarlos aquí:

• Programa de registro de mensajes CAN
• Programa para el tablero del simulador
• Programa de prototipo / tablero final

Debe tener en cuenta que esos programas realmente no coinciden con el pseudocódigo aquí, contienen muchas cosas "extra" que realmente no son necesarias y si no está familiarizado con la programación orientada a objetos, probablemente puede ser un poco difícil de leer..

Paso 7: el hardware final

Cuando esté satisfecho con su programa (recuerde probar el prototipo en el automóvil después de la prueba final con la placa del simulador), es el momento de construir el hardware real.

Tienes tres opciones aquí:

• Rápido y sucio: suelde las cosas juntas en una placa prototipo de PCB.
• Bricolaje incondicional: grabe su propia PCB.
• La forma perezosa: solicite una PCB profesional para soldar los componentes.

Si no tienes prisa te puedo recomendar la última opción. Si solo necesita un PCB pequeño como este, es muy barato pedirlo en China. (Y luego probablemente obtendrá diez piezas más o menos para que pueda permitirse algunos errores de soldadura).

Para pedir PCB, deberá enviar su diseño en formato Gerber. Hay varios programas para esto. Usé Eagle, que puedo recomendar. Puede esperar unas horas para aprenderlo, pero luego funciona bien. Para tablas pequeñas como esta, puedes usarlo gratis.

Tenga cuidado al hacer el diseño. No querrá esperar cuatro semanas para la entrega solo para descubrir que hizo algo mal.

(Si tiene buenas habilidades para soldar, puede diseñar para componentes montados en superficie y obtener un adaptador realmente pequeño. Yo no lo hice).

Luego ordene en, por ejemplo, https://www.seeedstudio.com/fusion_pcb.html. Siga las instrucciones sobre cómo generar los archivos Gerber a partir de su diseño. También puede obtener una vista previa del resultado para asegurarse de que esté bien.

(Al final, tuve que seleccionar otras resistencias para R4-R7 que las que se enumeran en la imagen esquemática. En su lugar, usé 2k, 4.7k, 6.8k y 14.7k).

Y recuerde: ¡no confunda la numeración de pines de Atmega con la numeración de pines de Arduino!

Le recomiendo que no suelde el chip Atmega directamente, sino que utilice un enchufe. Luego, puede quitarlo fácilmente en caso de que necesite reprogramarlo.

Paso 8: Montaje en el automóvil

Ahora, a la parte más divertida: ¡móntelo en su automóvil y comience a usarlo! (Después de haber hecho / comprado un estuche).

Si ya ha probado completamente el prototipo en su automóvil, todo debería funcionar perfectamente.

(Como mencioné anteriormente, no lo hice, así que tuve que reemplazar algunas resistencias y hacer algunos cambios en mi programa).

También considere si debe montarlo detrás del estéreo o en otro lugar. Encontré un buen lugar encima de mi guantera donde puedo alcanzarlo desde el interior de la guantera sin desarmar nada. Eso podría ser útil si decido actualizarlo más tarde.

¡Finalmente mis botones están funcionando de nuevo! ¿Cómo podría sobrevivir dos meses sin ellos?

Paso 9: Mejoras futuras

Como se mencionó, si hago una versión 2.0 de esto, reemplazaré el 4066B con algo más (probablemente un potenciómetro digital) para una mayor flexibilidad.

También hay muchas otras cosas que puede hacer. P.ej. agregue un módulo bluetooth y cree una aplicación de control remoto para su teléfono. O un módulo gps, luego, cuando esté cerca de casa, puede subir el volumen automáticamente y enviar el mensaje CAN de "ventanas abajo" para que todos sus vecinos puedan disfrutar de su maravillosa música.