Arduino personnalisé pour conserver les boutons du volant CAN avec le nouvel autoradio : 9 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

J'ai décidé de remplacer l'autoradio d'origine de ma Volvo V70-02 par une nouvelle chaîne stéréo afin de pouvoir profiter de choses comme mp3, bluetooth et mains libres.

Ma voiture a des commandes au volant pour la chaîne stéréo que j'aimerais pouvoir toujours utiliser. Je ne m'attendais pas à ce que ce soit un problème car il existe plusieurs adaptateurs sur le marché qui sont censés être compatibles avec ma voiture. Cependant, j'ai vite découvert qu'ils ne l'étaient pas ! (Il semble que les adaptateurs pour V70 puissent avoir des problèmes avec les voitures -02 en raison d'un protocole CAN légèrement différent.)

Alors que faire alors ? Garder l'ancienne chaîne stéréo ? Vivre une vie avec des boutons qui ne fonctionnent pas ? Bien sûr que non! S'il n'y a pas d'adaptateur fonctionnel sur le marché, nous devrons en construire un !

Cette instructable peut être appliquée (avec quelques adaptations) aux voitures où les boutons du volant communiquent via le bus CAN.

Étape 1: Découvrez comment envoyer des commandes à la chaîne stéréo

La première chose à faire est de déterminer le type d'entrée à distance attendu par la chaîne stéréo. Généralement, les fabricants ne vous le diront pas et vous n'avez probablement pas non plus accès à des télécommandes fonctionnelles pour la rétro-ingénierie.

La télécommande de ma nouvelle chaîne stéréo (Kenwood) se compose d'un seul fil et je n'ai pu trouver aucune information sur son fonctionnement. Cependant, il dispose également d'une prise jack 3,5 mm pour l'entrée à distance. Je n'ai rien trouvé non plus à ce sujet. Mais il existe quelques informations sur un jack 3,5 mm pour d'autres marques suggérant que différentes commandes sont identifiées en appliquant une résistance spécifique entre la pointe et le manchon (et éventuellement entre la bague et le manchon). Par exemple. https://forum.arduino.cc/index.php?topic=230068.0. J'ai donc décidé d'essayer, équipé d'une planche à pain, d'un tas de résistances et d'une prise 3,5 mm branchée sur la stéréo et connectée à la planche à pain. Rien n'a été reconnu au début, mais la chaîne stéréo a un menu "mode d'apprentissage" et là, les commandes peuvent être configurées avec succès tout en appliquant diverses résistances. Succès!

Cependant, j'ai découvert plus tard que j'avais fait une erreur ici: toutes les commandes que la chaîne stéréo semblait apprendre ne fonctionneraient pas réellement. Par exemple. 30 kOhm ont été trouvés en mode d'apprentissage mais n'ont pas fonctionné plus tard et pour certaines des commandes que j'ai configurées, la différence de résistance était si petite que plus tard, la mauvaise commande a été déclenchée.

Je vous recommande donc d'utiliser une maquette avec des résistances et des boutons de commutation pour toutes les commandes à distance que vous souhaitez gérer et de tester réellement que toutes fonctionnent.

Si votre autoradio ne peut pas recevoir d'entrée de la même manière, vous devrez alors comprendre comment cela fonctionne afin de pouvoir adapter cette solution. Si vous n'arrivez pas à comprendre du tout, vous avez un problème.

Étape 2: Découvrez où se connecter au bus CAN

Vous devez localiser un bon endroit pour vous connecter au bus CAN. Puisque vous remplacez une ancienne chaîne stéréo qui communique via CAN, vous devriez pouvoir la trouver derrière la chaîne stéréo. Le bus CAN se compose d'une paire de fils torsadés (CAN-L et CAN_H). Consultez un schéma de câblage pour votre voiture pour être sûr.

Étape 3: Ingénierie inverse des messages CAN

À moins que Google ne puisse vous dire quels messages CAN vous devez écouter, vous devrez vous connecter au bus CAN et effectuer une ingénierie inverse. J'ai utilisé un Arduino Uno et un shield CAN. (Vous n'avez pas vraiment besoin du bouclier CAN, comme vous le verrez plus tard, vous pouvez utiliser à la place des composants bon marché sur une maquette.)

Consultez Google pour savoir quel débit en bauds vous devez utiliser lors de la connexion à votre voiture. (En règle générale, vous constaterez qu'il existe un réseau CAN à grande vitesse et un réseau à faible vitesse. Vous vous connectez au réseau à faible vitesse.)

Vous devrez également programmer l'Arduino pour enregistrer tous les messages CAN via l'interface série afin que vous puissiez les enregistrer dans un fichier journal sur votre ordinateur. L'IDE Arduino standard n'enregistrera pas les données dans un fichier journal, mais vous pouvez utiliser par ex. Du mastic à la place.

Avant de commencer à écrire votre programme, vous devez installer la bibliothèque CAN_BUS_Shield.

Voici quelques pseudo-codes pour vous aider à démarrer votre programme:

mettre en place()

{ init serial connection init CAN library } loop() { si le message CAN est reçu { lire l'entrée du journal du format du message CAN écrire l'entrée du journal sur la série } }

Conseils:

Vous utiliserez une instance de la classe MCP_CAN pour accéder à la fonctionnalité de la bibliothèque CAN:

MCP_CAN m_can;

L'initialisation peut:

tandis que (m_can.begin() != CAN_OK)

{ retard (1000); }

Recherchez et lisez les messages CAN:

while(m_can.checkReceive() == CAN_MSGAVAIL)

{ // Récupère l'ID CAN, la longueur du message et les données du message m_can.readMsgBufID(&m_canId, &m_msgLen, m_msgBuf); // Faites quelque chose avec les données du message ici }

Si vous avez besoin de plus d'aide, vous pouvez trouver un lien vers mon programme dans une étape ultérieure. La bibliothèque CAN shield comprend également un exemple. Ou consultez instructable de mviljoen2 qui comprend une étape similaire.

Vous aurez d'abord besoin d'un fichier de référence pour vous aider à filtrer les données. Mettez le contact en mode radio et enregistrez tout pendant quelques minutes sans toucher à aucun bouton.

Ensuite, pour chacun des boutons, lancez l'enregistrement, appuyez sur le bouton et arrêtez l'enregistrement.

Lorsque vous avez terminé, vous devez filtrer tout ce qui se trouve dans votre journal de référence à partir de vos journaux de boutons pour trouver vos candidats. J'ai découvert qu'il restait encore beaucoup de messages, j'ai donc créé plus de journaux, puis j'ai demandé que "les candidats à la commande A doivent figurer dans tous les fichiers de bouton A et dans aucun des fichiers de référence". Cela ne me laissait que quelques possibilités à essayer.

Les journaux contiendront beaucoup de messages, vous devrez donc écrire un programme pour cela ou éventuellement utiliser Excel. (J'ai utilisé un programme avec des conditions très codées en dur pour mes besoins, donc je crains de ne pas pouvoir proposer un programme que vous puissiez utiliser.)

Un mot d'avertissement: vous ne pouvez pas être sûr qu'un bouton produira toujours un message identique. Certains bits peuvent contenir des compteurs incrémentiels, etc. (Vous pouvez toutefois exclure que l'identifiant du message soit le même.)

Si vous possédez une Volvo V70-02, voici ce que vous recherchez:

• Identifiant du message: 0x0400066Byte0: 0x00, 0x40, 0x80 ou 0xc0 (ne s'en soucie pas)
• Octet1: 0x00 (ne s'en soucie pas)
• Octet2: 0x00 (ne s'en soucie pas)
• Octet3: 0x00-0x07 (ne t'inquiète pas)
• Octet4: 0x1f (ne s'en soucie pas)
• Octet5: 0x40 (ne s'en soucie pas)
• Octet6: 0x40 (ne s'en soucie pas)
• Byte7: Identificateur de bouton: 0x77 = volume haut, 0x7b = volume bas, 0x7d = piste suivante, 0x7e = piste précédente.

Lorsque vous pensez avoir trouvé les commandes, il peut être judicieux de modifier le programme afin qu'il n'enregistre que les messages intéressants. Regardez la fenêtre du journal série pendant que vous appuyez sur les boutons pour vérifier que vous avez identifié les messages corrects.

Étape 4: Le prototype matériel

Votre matériel doit pouvoir:

1. Identifier les commandes reçues sur le bus CAN
2. Envoyer des commandes dans un autre format à la stéréo

Si vous avez suffisamment d'espace, vous pouvez utiliser un Arduino et un blindage CAN pour la première partie et attacher du matériel supplémentaire pour la seconde. Cependant il y a quelques inconvénients:

• Coût du bouclier CAN
• Taille
• L'alimentation Arduino ne sera pas contente si elle est connectée directement au 12V de votre voiture (elle fonctionnera probablement mais sa durée de vie sera probablement raccourcie).

J'ai donc utilisé à la place ce qui suit:

• Atmega 328, le "cerveau Arduino". (Il existe quelques variantes, obtenez celle qui est égale à celle sur Arduino Uno. Vous pouvez l'acheter avec ou sans chargeur de démarrage Arduino.)
• Cristal 16 MHz + condensateurs pour signal d'horloge.
• Émetteur-récepteur CAN MCP2551.
• Contrôleur CAN MCP2515.
• TSR1-2450, convertit 6,5-36V en 5V. (Non utilisé dans le prototype car le logiciel ne se souciera pas de l'alimentation.)
• Commutateur CD4066B qui sera utilisé lors de l'envoi de commandes à la chaîne stéréo.
• Quelques résistances. (Les valeurs peuvent être trouvées dans les schémas Eagle dans une étape ultérieure.)

Une bonne chose avec cette configuration est qu'elle est entièrement compatible avec l'Arduino et la bibliothèque CAN shield.

Si vous souhaitez gérer plus de quatre boutons, vous pouvez envisager d'utiliser autre chose que le CD4066B. Le CD4066B peut être décrit comme quatre commutateurs en un, chacun contrôlé par l'une des broches GPIO d'Atmegas. À chaque commutateur est connectée une résistance qui peut être utilisée pour contrôler la résistance utilisée comme entrée de la chaîne stéréo. Cela peut donc facilement être utilisé pour envoyer quatre commandes différentes. Si elles sont combinées, des valeurs de résistance supplémentaires peuvent être obtenues. C'est là qu'intervient l'erreur que j'ai mentionnée plus tôt. J'ai quatre boutons, mais j'ai prévu d'en implémenter deux en appui long et court pour me donner six commandes différentes. Mais à la fin, j'ai découvert que je ne pouvais pas trouver une combinaison de résistances qui me donnerait six combinaisons de travail. Il serait probablement possible de connecter un signal de sortie analogique à la stéréo (embout de 3,5 mm) à la place. (Notez que l'Atmega n'a pas de véritables broches de sortie analogiques, donc du matériel supplémentaire serait nécessaire.)

À des fins de test, j'ai également réalisé un simple simulateur "voiture et stéréo" à connecter à mon prototype. Cela facilite le débogage et à moins que vous n'aimiez vous asseoir dans votre voiture et programmer, je peux vous le recommander.

Le prototype est illustré par la maquette du bas dans l'image. Pour l'alimentation, la programmation et la journalisation en série, il est connecté à un Arduino Uno où la puce Atmega a été retirée.

La planche à pain supérieure est le simulateur voiture + stéréo qui sera utilisé pour les premiers tests du prototype.

Le prototype + simulateur est destiné à fonctionner comme ceci:

• Appuyez sur l'un des boutons de commutation sur la carte du simulateur. (Ce sont les boutons de votre volant.)
• Lorsque le programme du simulateur détecte une pression sur un bouton, il enverra le message CAN correspondant toutes les 70 ms tant que le bouton est enfoncé. (Parce que les journaux que j'ai pris plus tôt indiquaient que c'était ainsi que cela fonctionnait dans ma voiture.) Il enverra également de nombreux messages CAN "indésirables" pour simuler d'autres trafics sur le bus.
• Les messages CAN sont envoyés sur le bus CAN.
• Les messages CAN sont reçus par le prototype.
• Le MCP2515 lance tous les messages non liés en fonction de l'identifiant du message.
• Lorsque le MCP2515 reçoit un message qui doit être traité, il indique qu'il a un message en file d'attente.
• L'Atmega lira le message et décidera quel bouton doit être considéré comme actif.
• L'Atmega gardera également une trace du moment où le dernier message a été reçu, après un certain temps, le bouton sera considéré comme relâché. (Les messages CAN indiquent uniquement qu'un bouton est enfoncé, pas qu'il a été poussé ou relâché.)
• Si un bouton est considéré comme actif, un ou plusieurs commutateurs du CD4066B seront activés.
• Le simulateur (agissant maintenant comme votre stéréo) détectera qu'une résistance est appliquée entre la pointe et le manchon. (La pointe est connectée à 3,3 V et via une résistance à une broche d'entrée analogique. Lorsqu'aucune commande n'est active, cette broche lira 3,3 V, lorsqu'une commande est active, la valeur deviendra inférieure et identifiera la commande.
• Tant qu'une commande est active, la led correspondante sera également activée. (Il y a six leds car j'avais prévu d'utiliser des appuis longs/courts différents pour deux de mes boutons.)

Pour plus de détails sur le matériel du prototype, voir les schémas Eagle dans une étape ultérieure.

Détails supplémentaires sur le matériel de la carte du simulateur:

• Cristal de 16 MHz
• Condensateurs 22 pF
• Les résistances LED doivent être sélectionnées en fonction des propriétés des LED
• Résistance connectée à A7 et 3.3V, sélectionnez par ex. 2kOhm (pas critique).
• Les résistances connectées aux MCP2551 et MCP2515 sont pull-up / pull-down. Sélectionnez par ex. 10 kOhms.

(Ou vous pouvez utiliser le bouclier CAN pour la "partie CAN" du simulateur si vous préférez.)

Il est important que vous sachiez comment les broches Atmega sont mappées sur les broches Arduino lorsque vous concevez le matériel.

(Ne connectez aucune led directement au CD 4066B, il ne peut gérer qu'un faible courant. J'ai essayé cela lorsque j'ai testé la sortie pour la première fois et la puce est devenue inutile. La bonne chose est que j'en avais acheté quelques-unes juste parce qu'elles sont si bon marché.)

Étape 5: programmation des fusibles

Peut-être avez-vous remarqué à l'étape précédente que le prototype n'a pas de composants séparés pour générer le signal d'horloge vers le MCP2515. C'est parce qu'il existe déjà un cristal de 16 MHz utilisé comme signal d'horloge Atmega que nous pouvons utiliser. Mais on ne peut pas simplement le connecter directement au MCP2515 et par défaut il n'y a pas de signal de sortie d'horloge sur l'Atmega.

(Si vous préférez, vous pouvez ignorer cette étape et ajouter le matériel d'horloge supplémentaire à la place.)

Cependant, nous pouvons utiliser quelque chose appelé "programmation de fusibles" pour activer un signal de sortie d'horloge sur l'une des broches GPIO.

Vous devrez d'abord localiser un fichier nommé "boards.txt" utilisé par votre IDE Arduino. Vous devrez copier l'entrée pour Arduino Uno, lui donner un nouveau nom et modifier la valeur de low_fuses.

Mon nouveau tableau ressemble à ceci:

##################################################### ############ # Basé sur Arduino Uno # Changements: # low_fuses est passé de 0xff à 0xbf pour activer l'horloge de 16 MHz # sur Atmega PB0/pin 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.bootloader.extended_fuses=0bootfd clkuno.bootloader.high_fuses=0xde clkuno.bootloader.extended_fuses=0bootfd clkuno..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=ant.build.build

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

Notez que l'horloge de sortie est activée en mettant son bit de contrôle à 0.

Lorsque vous aurez créé la nouvelle carte dans le fichier de configuration des cartes, vous devrez graver un nouveau chargeur de démarrage sur l'Atmega. Il existe différentes manières de le faire, j'ai utilisé la méthode décrite dans

Après avoir fait cela, n'oubliez pas de sélectionner votre nouveau type de carte et non l'Arduino Uno lorsque vous téléchargez un programme sur l'Atmega.

Étape 6: Le logiciel

Il est temps de rendre le matériel stupide intelligent en ajoutant des logiciels.

Voici quelques pseudo-codes pour le prototype:

lastReceivedTime = 0

lastReceivedCmd = aucun cmdTimeout = 100 setup() { activer le chien de garde configurer les broches D4-D7 comme broches de sortie init configurer CAN filtre CAN } boucle() { réinitialiser le chien de garde si (le message CAN est reçu) { pour chaque commande de bouton { si le message CAN appartient à la commande de bouton { lastReceivedTime = now lastReceivedCmd = cmd } } } if now > lastReceivedTime + cmdTimeout { lastReceivedCmd = none } pour chaque commande de bouton { si lastReceivedCmd est la commande de bouton { set command pin output = on } else { set command pin output = off } } }

cmdTimeout décide combien de temps nous devons attendre avant de considérer le dernier bouton actif relâché. Étant donné que les commandes de message CAN du bouton sont envoyées environ toutes les 70 ms, elles doivent être plus grandes que cela avec une certaine marge. Mais s'il est trop grand, il y aura une expérience de décalage. Donc 100 ms semble être un bon candidat.

Mais qu'est-ce qu'un chien de garde ? C'est une petite fonctionnalité matérielle utile qui peut nous sauver en cas de plantage. Imaginez que nous ayons un bogue provoquant le plantage du programme alors que la commande d'augmentation du volume est active. On se retrouverait alors avec la stéréo au volume max ! Mais si le chien de garde n'est pas réinitialisé pour l'heure spécifique, il décidera que quelque chose d'inattendu s'est produit et émettra simplement une réinitialisation.

void setup()

{ // autorise max 250 ms pour la boucle wdt_enable(WDTO_250MS); // autre truc d'init } void loop() { wdt_reset(); // faire des choses }

PEUT filtrer ? Eh bien, vous pouvez configurer le contrôleur CAN pour éliminer tous les messages qui ne correspondent pas au filtre afin que le logiciel ne perde pas de temps sur des messages qui ne nous intéressent pas.

masque long non signé = 0x1fffffff; // Inclut les 29 bits d'en-tête dans le masque

long filterId non signé = 0x0400066; // Nous ne nous soucions que de cet identifiant de message CAN m_can.init_Mask(0, CAN_EXTID, mask); // Le masque 0 s'applique au filtre 0-1 m_can.init_Mask(1, CAN_EXTID, mask); // Le masque 1 s'applique au filtre 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);

Consultez le code de la bibliothèque CAN et la documentation du contrôleur CAN pour plus de détails sur la configuration du filtre + masque.

Vous pouvez également configurer le contrôleur CAN pour déclencher une interruption lorsqu'un message (qui n'est pas filtré) est reçu. (Non inclus dans l'exemple ci-dessus mais il y a du code pour cela dans mon programme.) Dans ce cas, cela n'ajoute pas vraiment de valeur et cela peut être déroutant si vous n'êtes pas habitué à la programmation.

C'était donc le logiciel prototype en résumé. Mais nous avons également besoin de code pour la carte du simulateur:

lastSentTime = 0

minDelayTime = 70 setup() { configurer les broches A0-A5 comme broches de sortie configurer les broches D4-D7 comme broches d'entrée avec pullup interne. init CAN } loop() { envoyer "junk" peut msg définir activeButton = aucun pour chaque bouton { si le bouton est enfoncé { définir activeButton = bouton } } si activeButton != aucun { si maintenant > lastSentTime + minDelayTime { envoyer la commande du bouton peut envoyer un message } set lastSentTime = now } inval = read pin A7 foreach(cmd) { if (min < inval < max) { led on } else { led off } } attendre 1 ms }

Cela enverra en continu des messages CAN "indésirables" environ toutes les ms et pendant qu'un bouton est enfoncé, la commande correspondante toutes les 70 ms.

Vous devrez peut-être enregistrer l'entrée sur la broche A7 tout en appuyant sur les différents boutons pour trouver les valeurs appropriées pour les variables min et max appartenant à chaque bouton. (Ou vous pouvez le calculer, mais la lecture de l'entrée vous donnera des valeurs plus précises.)

Vous devez être un peu prudent lorsque vous programmez les modes de broche. Si vous définissez accidentellement les broches destinées à utiliser le pullup interne comme broches de sortie à la place, vous créerez un raccourci potentiel qui endommagera votre Arduino lorsque vous réglez la sortie à un niveau élevé.

Si vous voulez vérifier mes programmes, ils peuvent être téléchargés ici:

• Programme de journal des messages CAN
• Programme pour la carte simulateur
• Programme pour prototype / planche finale

Vous devez être conscient que ces programmes ne correspondent pas vraiment au pseudo-code ici, ils contiennent beaucoup de choses "extra" qui ne sont pas vraiment nécessaires et si vous n'êtes pas familier avec la programmation orientée objet, cela peut probablement être un peu difficile à lire.

Étape 7: le matériel final

Lorsque vous êtes satisfait de votre programme (n'oubliez pas de tester le prototype dans la voiture après les tests finaux avec la carte du simulateur), il est temps de construire le vrai matériel.

Vous avez trois options ici:

• Rapide et sale - soudez les éléments ensemble sur une carte prototype de PCB.
• Hardcore DIY - gravez votre propre PCB.
• La manière paresseuse - commandez un PCB professionnel pour souder les composants.

Si vous n'êtes pas pressé, je peux vous recommander la dernière option. Si vous n'avez besoin que d'un petit PCB comme celui-ci, il est très bon marché de le commander en Chine. (Et puis vous obtiendrez probablement une dizaine de pièces afin que vous puissiez vous permettre des erreurs de soudure.)

Pour commander des PCB, vous devrez envoyer votre conception au format Gerber. Il existe différents logiciels pour cela. J'ai utilisé Eagle que je peux recommander. Vous pouvez vous attendre à quelques heures pour l'apprendre, mais cela fonctionne très bien. Pour les petites planches comme celle-ci, vous pouvez l'utiliser gratuitement.

Soyez prudent lorsque vous faites la conception. Vous ne voulez pas attendre quatre semaines pour la livraison juste pour découvrir que vous avez fait quelque chose de mal.

(Si vous avez de bonnes compétences en soudure, vous pouvez concevoir des composants montés en surface et obtenir un très petit adaptateur. Je ne l'ai pas fait.)

Ensuite, commandez par ex. https://www.seeedstudio.com/fusion_pcb.html. Suivez les instructions pour générer les fichiers Gerber à partir de votre conception. Vous pouvez également obtenir un aperçu du résultat pour vous assurer qu'il est ok.

(En fin de compte, j'ai dû sélectionner d'autres résistances pour R4-R7 que celles répertoriées dans l'image du schéma. Au lieu de cela, j'ai utilisé 2k, 4,7k, 6,8k et 14,7k.)

Et rappelez-vous - ne confondez pas la numérotation des broches Atmega avec la numérotation des broches Arduino!

Je vous recommande de ne pas souder directement la puce Atmega mais d'utiliser un socket. Ensuite, vous pouvez facilement le supprimer au cas où vous auriez besoin de le reprogrammer.

Étape 8: Montage de la voiture

Passons maintenant à la partie la plus amusante: montez-le dans votre voiture et commencez à l'utiliser ! (Après avoir fabriqué / acheté un étui pour cela.)

Si vous avez déjà entièrement testé le prototype dans votre voiture, tout devrait fonctionner parfaitement.

(Comme je l'ai mentionné plus tôt, je ne l'ai pas fait, j'ai donc dû remplacer certaines résistances et apporter quelques modifications à mon programme.)

Considérez également si vous devez le monter derrière la chaîne stéréo ou ailleurs. J'ai trouvé un bon endroit au-dessus de ma boîte à gants où je peux l'atteindre de l'intérieur de la boîte à gants sans rien démonter. Cela pourrait être utile si je décide de le mettre à niveau plus tard.

Enfin mes boutons fonctionnent à nouveau ! Comment pourrais-je survivre pendant deux mois sans eux ?

Étape 9: Améliorations futures

Comme mentionné, si j'en fais une version 2.0, je remplacerai le 4066B par autre chose (probablement un potentiomètre numérique) pour une plus grande flexibilité.

Il y a aussi beaucoup d'autres choses que vous pouvez faire. Par exemple. ajoutez un module Bluetooth et créez une application de contrôle à distance pour votre téléphone. Ou un module gps, puis lorsque vous êtes près de chez vous, vous pouvez automatiquement augmenter le volume et envoyer le message CAN "fenêtres baissées" afin que tous vos voisins puissent profiter de votre merveilleuse musique.