DIY Givi V56 Kit d'éclairage pour Topbox de moto avec signaux intégrés: 4 étapes (avec photos)

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

En tant que motard, je suis trop habitué à être traité comme si j'étais invisible sur la route. Une chose que j'ajoute toujours à mes vélos est un top case qui a généralement un éclairage intégré. J'ai récemment mis à niveau vers un nouveau vélo et acheté la boîte Givi V56 Monokey car elle avait beaucoup d'espace pour les articles. Cette boîte a un spot pour un kit d'éclairage d'usine qui se compose de deux bandes de LED pour chaque côté. Le problème est que ce kit coûte environ 70 $ et ne fait que des freins. Il existe un kit de rechange qui fait probablement des choses similaires et pourrait être un peu plus facile à installer, mais votre prix monte jusqu'à 150 $. Étant une personne ingénieuse et cherchant une excuse pour essayer les bandes LED adressables, j'ai décidé de créer un système intégré qui aurait non seulement des feux de freinage, mais aussi des feux de position (allumés chaque fois que vous vous déplacez), des clignotants et des feux de détresse. Juste pour le plaisir, j'ai même ajouté une séquence de démarrage…. parce que je pouvais. Notez que cela a pris beaucoup de travail à faire même si j'avais beaucoup de choses à comprendre. Malgré le travail, je suis plutôt content du résultat. Espérons que cela finira par être utile à quelqu'un d'autre.

Le fonctionnement de base du fonctionnement de ce système est que l'unité Arduino recherche des signaux sur les broches: feu stop, feu de virage à gauche et feu de virage à droite. Afin de lire le signal 12 volts de la moto, j'ai utilisé des opto-isolateurs pour convertir le signal 12V en un signal 5V qu'Arduino peut lire. Le code attend ensuite l'un de ces signaux puis envoie les commandes à la bande LED à l'aide de la bibliothèque FastLED. C'est la base, maintenant pour entrer dans les détails.

Fournitures

Ce sont les choses que j'ai utilisées parce que pour la plupart je les avais déjà traînées. Evidemment, ils peuvent être échangés selon les besoins:

1. Arduino - J'ai utilisé un nano pour des considérations de taille, mais vous pouvez utiliser ce que vous voulez tant que vous avez cinq broches à utiliser.
2. Régulateur 5V - J'ai utilisé un L7805CV capable de 1,5 ampères. Ce projet utilisera 0,72 ampères pour les LED plus la puissance pour le nano, donc 1,5 fonctionne très bien pour ce projet.
3. Condensateurs - vous aurez besoin d'un 0,33 uF et d'un autre de 0,1 uF pour que le régulateur de tension fonctionne correctement.
4. 3x opto-isolateurs - pour faire la conversion du signal de 12V à 5V. J'ai utilisé le type PC817X qui n'a que quatre broches, ce dont nous avons besoin.
5. Résistances - vous aurez besoin de deux types, trois de chaque type. Le premier doit être suffisant pour réduire le courant à travers l'optoisolateur LED IR. Vous aurez besoin d'au moins 600 ohms, mais 700 serait une meilleure idée pour gérer les changements de tension sur la moto. L'autre doit être quelque part entre 10k et 20k pour un signal rapide de l'autre côté de l'optoisolateur.
6. Planche prototype - j'en ai eu qui étaient assez petites pour tenir dans une petite boîte de projet avec une légère quantité de rognage.
7. Boîte de projet - assez grande pour contenir les composants, mais assez petite pour être facile à installer.
8. Fil - J'ai utilisé du fil Ethernet Cat 6 parce que j'en avais beaucoup assis. Cela a huit fils tous codés par couleur qui ont aidé avec toutes les différentes connexions et était une jauge assez grande pour gérer les tirages de courant.
9. Bouchons - partout où vous voulez que le système soit facilement amovible. J'ai utilisé un bouchon étanche pour permettre de retirer le top case et pour gérer la pluie ou l'eau qui s'y infiltre. J'avais également besoin de fiches plus petites pour les bandes LED afin de ne pas avoir à percer de gros trous.
10. Attaches zippées et supports adhésifs pour attaches zippées pour tout maintenir en place.
11. Film rétractable pour ranger les connexions.

Étape 1: Construire le circuit

Évidemment, si vous suivez ma construction, vous n'aurez pas à passer par la quantité de tests que j'ai fait. La première chose que j'ai faite a été de m'assurer que mon code fonctionnait et que je pouvais correctement obtenir un signal des opto-isolateurs ainsi que contrôler correctement les bandes LED. Il a fallu un moment pour trouver la meilleure façon de fixer les broches de signal aux isolateurs, mais par essais et erreurs, j'ai trouvé la bonne orientation. J'ai juste utilisé une carte prototype standard car je n'en construisais qu'une et trouver un motif de trace aurait pris plus de temps qu'il n'en valait la peine. La partie supérieure du circuit imprimé a fière allure, mais le bas ressemble un peu à un désordre, mais au moins c'est fonctionnel.

La conception de base commence par l'entrée de l'alimentation 12V à partir d'une source commutée (un fil qui n'est allumé que lorsque la moto est allumée). Un schéma de câblage peut vraiment aider à trouver ce fil. Ceci est introduit dans un côté du régulateur de tension. Un condensateur de 0,33 uF relie cette entrée à la terre sur le régulateur de tension qui renvoie ensuite à la terre sur la moto. La sortie du régulateur de tension aura un condensateur de 0,1 uF relié à la terre. Ces condensateurs aident à lisser la tension du régulateur. Si vous ne les trouvez pas sur l'image du circuit imprimé, ils se trouvent sous le régulateur de tension. De là, la ligne 5V va au Vin sur l'Arduino, à la broche d'alimentation qui alimentera les bandes LED, et deux au côté Source de l'optoisolateur qui alimentera les broches Arduino fournissant le signal 5V nécessaire.

Quant aux optoisolateurs, il y a deux faces: l'une avec une LED IR et l'autre avec un transistor avec et détecteur IR. Nous voulons utiliser le côté LED IR pour mesurer le signal 12V. Étant donné que la LED a une tension directe de 1,2 V, nous avons besoin d'une résistance de limitation de courant en série. 12V - 1,2V = 10,8V et pour faire fonctionner la LED à 18 mA (j'aime toujours faire fonctionner moins de 20 mA pour des raisons de durée de vie), vous aurez besoin d'une résistance de R = 10,8V/0,018A = 600 ohm. Les tensions sur les véhicules ont également tendance à être plus élevées, potentiellement jusqu'à 14 V, il est donc préférable de prévoir cela, qui est d'environ 710 ohms, bien que 700 serait plus que raisonnable. La sortie du côté LED est ensuite renvoyée à la terre. Pour le côté sortie de l'optoisolateur, l'entrée utilisera le signal 5V du régulateur puis la sortie se connectera à une autre résistance avant de passer à la terre. Cette résistance doit juste être d'environ 10k - 20k ohm, du moins c'est ce que ma fiche technique a montré. Cela donnera une mesure rapide du signal puisque nous n'avons pas affaire à un environnement bruyant. La sortie vers la broche Arduino se détachera entre la résistance et la sortie de l'optoisolateur de sorte que lorsque le signal est désactivé, la broche est faible et lorsque le signal est activé, la broche est élevée.

Les bandes lumineuses à LED sont associées à trois fils: alimentation, terre et données. L'alimentation doit être de 5V. Ce projet utilise 12 LED au total (bien que j'aie plus de LED sur les bandes mais je n'utilise qu'une LED sur trois) et chacune prend 60 mA lorsque la lumière blanche est utilisée à pleine luminosité. Cela donne un total de 720 mA. Nous sommes bien dans la puissance de sortie du régulateur de tension, donc nous sommes bons. Assurez-vous simplement que le fil est d'un calibre suffisamment gros pour gérer l'alimentation, j'ai utilisé un fil Ethernet Cat 6 de calibre 24. Le fil Ethernet était quelque chose que j'avais assis et il a 8 fils codés par couleur, donc cela a bien fonctionné pour ce projet. Les seuls fils qui doivent ensuite aller au topbox lui-même sont l'alimentation et la terre (qui sont tous deux répartis entre les bandes) et deux lignes de données (une pour chaque bande).

Le reste du câblage se connecte aux broches de l'arduino et l'alimente. Les broches qui ont été utilisées pour ce projet étaient les suivantes:

1. Vin - connecté à 5V
2. Gnd - connecté à la terre
3. Pin2 - connecté à la ligne de données de la bande gauche
4. Pin3 - connecté à la ligne de données de la bande droite
5. Pin4 - connecté au signal de freinage de l'optoisolateur
6. Pin5 - connecté au clignotant gauche de l'optoisolateur
7. Pin6 - connecté au clignotant droit de l'optoisolateur

Étape 2: Câblage et installation

Une fois le circuit construit, vient le temps de le câbler en place. À l'aide du schéma de câblage de votre vélo, vous devrez localiser les éléments suivants:

• Alimentation à découpage
• Sol
• Signal de freinage entrant
• Clignotant gauche
• Clignotant droit

Pour le mien, il y avait une seule prise qui avait tout cela, alors je l'ai juste utilisé. Avec suffisamment de temps, j'aurais peut-être pu trouver le même style de prise et juste faire un module enfichable, mais je ne l'ai pas fait, alors j'ai juste retiré l'isolation par endroits et j'y ai soudé le nouveau fil. J'ai utilisé des fiches sur ces connexions épissées afin de pouvoir retirer le reste si j'en avais besoin à l'avenir. De là, j'ai placé l'Arduino, qui est maintenant dans une boîte de projet scellée, sous le siège où je l'ai attaché. Le câble de sortie longe ensuite le cadre du rack jusqu'à une prise étanche, puis pénètre dans la boîte et longe l'arrière jusqu'au couvercle où il se divise de chaque côté. Les fils longent l'intérieur du couvercle jusqu'au point où se trouvent les connexions pour les LED. Le fil est mis en place à l'aide d'attaches zippées fixées à des supports d'attaches zippées de qualité extérieure avec un support adhésif. Vous pouvez les trouver dans la section d'installation de câbles dans un magasin de rénovation domiciliaire

J'ai utilisé deux mini fiches JST sur les bandes LED car j'avais besoin d'une fiche assez petite pour passer par un trou de diamètre minimum et parce que je voulais m'assurer qu'il y avait suffisamment de fil pour répondre aux exigences actuelles. Encore une fois, c'était peut-être exagéré et je n'avais pas de petites prises à trois fils à portée de main. Le trou dans la boîte pour le passage des fils de la bande lumineuse a été scellé pour empêcher l'eau d'entrer. En ce qui concerne le positionnement des bandes LED, car il y a un léger décalage dans l'espacement (il y avait une différence d'espacement d'environ 1 à 1,5 mm entre les trous du réflecteur et les LED), je les ai positionnés de manière à ce qu'ils divisent la différence entre la LED et le trou autant que possible. J'ai ensuite utilisé de la colle chaude pour les coller en place et du mastic pour sceller complètement la zone. Les bandes LED elles-mêmes sont étanches, donc pas de problème si elles sont mouillées. Bien que cela semble beaucoup à installer, cela rend le système plus facile à retirer à l'avenir ou le remplacement de pièces est nécessaire car cela pourrait arriver.

Étape 3: Le code

Mon code source devrait être au début de ce Instructable. Je commente toujours beaucoup mon code pour qu'il soit plus facile à comprendre plus tard. Avis de non-responsabilité: je ne suis pas un écrivain de code professionnel. Le code a été écrit dans une méthode qui était plus facile à démarrer et quelques améliorations ont été apportées, mais je sais qu'il pourrait être plus affiné. J'utilise également une grande partie de la fonction delay () pour le timing, ce qui n'est pas aussi idéal. Cependant, les signaux que l'unité reçoit ne sont pas des signaux rapides en comparaison, je me sentais donc toujours justifié de les conserver en utilisant quelque chose comme millis(). Je suis également un père et un mari très occupés, donc passer du temps à améliorer quelque chose qui ne changera finalement pas la fonction n'est pas en haut de la liste.

Pour ce projet, une seule bibliothèque est requise qui est la bibliothèque FastLED. Celui-ci possède tout le code pour contrôler les bandes LED de type WS2811/WS2812B. À partir de là, je couvrirai les fonctions de base qui seront utilisées.

La première autre que les définitions standard est de déclarer vos deux bandes. Vous utiliserez le code suivant pour chaque bande:

FastLED.addLeds(leds[0], NUM_LEDS);

Cette ligne de code configure la broche 2 définit cette bande comme bande 0 avec le nombre de LED défini par la constante NUM_LEDS, qui dans mon cas est définie sur 16. Pour définir la deuxième bande, le 2 deviendra 3 (pour la broche3) et la bande sera étiquetée bande 1.

La prochaine ligne qui sera importante est la définition des couleurs.

leds[0][1] = Color_high CRGB(r, g, b);

Cette ligne de code est utilisée dans des looks différents (la plupart de mes utilisations sont une constante). Fondamentalement, ce code envoie une valeur à chacun des canaux LED (rouge, vert, bleu) qui définit chaque luminosité. La valeur de luminosité peut être définie par un nombre compris entre 0 et 255. En modifiant le niveau de luminosité pour chaque canal, vous pouvez définir différentes couleurs. Pour ce projet, je veux une couleur blanche pour garder la lumière aussi brillante que possible. Donc, les seuls changements que je fais sont de régler le niveau de luminosité de la même manière sur les trois canaux.

Le prochain ensemble de codes est utilisé pour allumer individuellement chaque lumière. Notez que pour chaque bande, chaque LED a une adresse qui commence à 0 pour celle la plus proche de la connexion de la ligne de données jusqu'au nombre de LED le plus élevé que vous avez moins 1. Exemple, ce sont 16 bandes de LED, donc la plus élevée est 16 - 1 = 15. La raison en est que la première LED est étiquetée 0.

for (int i = NUM_LEDS-1; i > -1; i = i - 3) { // Cela changera la lumière pour chaque troisième LED allant de la dernière à la première. leds[0] = Color_low; // Réglez la couleur de la LED de la bande 0 sur la couleur choisie. leds[1] = Color_low; // Réglez la couleur de la LED de la bande 1 sur la couleur choisie. FastLED.show(); // Affiche les couleurs définies. leds[0] = CRGB::Noir; // Désactiver la couleur définie dans la préparation de la couleur suivante. leds[1] = CRGB::Noir; retard (150); } FastLED.show(); // Affiche les couleurs définies.

La façon dont ce code fonctionne est qu'une variable (i) est utilisée dans une boucle for comme adresse de LED qui est ensuite référencée au nombre complet de LED (NUM_LEDS). La raison en est que je veux que les lumières commencent à la fin de la bande plutôt qu'au début. Le réglage est transmis aux deux bandes (leds[0] et leds[1]) puis une commande pour montrer le changement est émise. Après cela, ce voyant s'éteint (CRGB::Black) et le voyant suivant s'allume. La référence Black est une couleur spécifique dans la bibliothèque FastLED, donc je n'ai pas à émettre 0, 0, 0 pour chaque canal bien qu'ils fassent la même chose. La boucle For fait avancer 3 LED à la fois (i = i-3) puisque je n'utilise qu'une LED sur deux. A la fin de cette boucle, la séquence lumineuse passera d'une LED à l'autre avec un seul allumé par bande, sorte d'effet Knight Rider. Si vous voulez garder chaque lumière allumée pour que la barre se construise, vous devez simplement supprimer les lignes qui éteignent les LED, ce qui se produit dans le prochain jeu de code du programme.

for (int i = 0; i < dim; i++) { // Atténue rapidement les lumières au niveau de la lumière courante. rt = rt + 1; gt = gt + 1; bt = bt + 1; for (int i = 9; i < NUM_LEDS; i = i +3) { // Cela allumera les trois derniers feux du feu de position. leds[0] = CRGB(rt, gt, bt); // Réglez la couleur de la LED de la bande 0 sur la couleur choisie. leds[1] = CRGB(rt, gt, bt); // Réglez la couleur de la LED de la bande 1 sur la couleur choisie. } FastLED.show(); retard(3); }

Le dernier exemple de code que j'utilise pour les LED est une boucle de fondu. Ici, j'utilise des emplacements temporaires pour la luminosité de chaque canal (rt, gt, bt) et je les incrémente de 1 avec un délai entre chaque diffusion pour obtenir l'apparence que je veux. Notez également que ce code ne change que les trois dernières LED car cela s'estompe dans les feux de position, donc je commence à 9 plutôt qu'à 0.

Le reste du code LED est constitué d'itérations de ceux-ci. Tout le reste est axé sur la recherche d'un signal sur les trois fils différents. La zone Loop () du code recherche les feux de freinage, qu'elle clignotera une fois avant de rester allumés (cela est réglable si vous le souhaitez) ou de rechercher des clignotants. Pour ce code, parce que je ne pouvais pas supposer que les clignotants gauche et droit s'allumeraient exactement en même temps pour les dangers, je fais d'abord rechercher l'un ou l'autre du code, puis après un petit délai, je vérifie si les deux sont allumés. les feux de détresse sont allumés. La seule partie délicate que j'ai eue était les clignotants car la lumière s'éteindra pendant un certain temps, alors comment puis-je faire la différence entre le signal toujours allumé mais en période d'arrêt et un signal annulé ? Ce que j'ai proposé, c'est d'implémenter une boucle de délai qui est configurée pour durer plus longtemps que le délai entre les clignotements du signal. Si le clignotant est toujours allumé, la boucle de signal continuera. Si le signal ne revient pas à la fin du délai, alors il revient au début de la boucle(). Pour ajuster la longueur du délai, modifiez le nombre de lightDelay constant en vous rappelant que pour chaque 1 dans lightDelay, le délai change de 100 ms.

while (digitalRead(leftTurn) == LOW) { for(int i = 0; i < lightDelay; i++) { leftTurnCheck(); if(digitalRead(leftTurn) == HIGH) { leftTurnLight(); } retard (100); } for (int i = 0; i < NUM_LEDS; i = i +3) { // Cela changera la lumière pour chaque troisième LED allant de la dernière à la première. leds[0] = CRGB(0, 0, 0); // Réglez la couleur de la LED de la bande 0 sur la couleur choisie. } for (int i = 9; i < NUM_LEDS; i = i +3) { // Ceci configurera les feux de position qui n'utilisent que les trois derniers. leds[0] = Color_low; // Réglez la couleur de la LED de la bande 0 sur la couleur choisie. } FastLED.show(); // Les paramètres de sortie sont renvoyés; // Une fois que le clignotant n'est plus allumé, retournez à la boucle. }

Espérons que le reste du code est explicite. C'est juste un ensemble répétitif de vérification et d'action sur les signaux.

Étape 4: Résultats

Ce qui est incroyable, c'est que ce système a fonctionné la première fois que je l'ai connecté au vélo. Maintenant, pour être juste, je l'ai fortement testé sur le banc avant cela, mais je m'attendais toujours à avoir un problème ou un ajustement. Il s'avère que je n'ai pas eu besoin de faire des ajustements au code ainsi qu'aux connexions. Comme vous pouvez le voir dans la vidéo, le système passe par la séquence de démarrage (que vous n'êtes pas obligé d'avoir), puis passe par défaut aux feux de position. Après cela, il recherche les freins, auquel cas il allume toutes les LED à pleine luminosité et les clignote une fois avant de rester allumé jusqu'à ce que les freins soient relâchés. Lorsqu'un clignotant est utilisé, j'ai créé un effet de défilement pour le côté où le virage est indiqué et l'autre côté sera soit des feux de circulation, soit des feux de freinage s'ils sont allumés. Les feux de détresse clignoteront juste en même temps que les autres feux.

J'espère qu'avec ces lumières supplémentaires, je serai plus visible pour les autres. À tout le moins, c'est un bel ajout pour faire ressortir un peu plus ma box que les autres tout en offrant de l'utilité. J'espère que ce projet sera également utile à quelqu'un d'autre, même s'il ne travaille pas avec un éclairage de top case de moto. Merci!