DIY Givi V56 Motorcycle Topbox Light Kit met geïntegreerde signalen - Ajarnpa

2025 Auteur: John Day | [email protected]. Laatst gewijzigd: 2025-01-13 06:57

Als motorrijder weet ik maar al te goed dat ik word behandeld alsof ik onzichtbaar ben op de weg. Een ding dat ik altijd aan mijn fietsen toevoeg, is een topkoffer die meestal een geïntegreerd licht heeft. Ik heb onlangs een upgrade naar een nieuwe fiets uitgevoerd en de Givi V56 Monokey-box gekocht omdat deze veel ruimte had voor items. Deze doos heeft een plek voor een fabrieksverlichtingsset die bestaat uit twee strips LED's voor elke kant. Het probleem is dat deze kit ongeveer $ 70 kost en alleen remmen doet. Er is een aftermarket-kit die waarschijnlijk vergelijkbare dingen doet en misschien een beetje eenvoudiger te installeren is, maar uw prijs loopt op tot $ 150. Omdat ik een vindingrijk persoon was en op zoek was naar een excuus om de adresseerbare LED-strips uit te proberen, besloot ik een geïntegreerd systeem te maken dat niet alleen remlichten zou hebben, maar ook looplichten (aan bij beweging), richtingaanwijzers en alarmlichten. Voor de grap heb ik zelfs een opstartvolgorde toegevoegd …. omdat ik het kon. Merk op dat dit veel werk kostte, hoewel ik veel dingen moest uitzoeken. Ondanks het werk ben ik best tevreden met hoe dit is geworden. Hopelijk is dit uiteindelijk nuttig voor iemand anders.

De basiswerking van hoe dit systeem werkt, is dat de Arduino-eenheid naar signalen op de pinnen zoekt: remlicht, linker richtingaanwijzer en rechter richtingaanwijzer. Om het 12 volt-signaal van de motorfiets te lezen, heb ik opto-isolatoren gebruikt om het 12V-signaal om te zetten in een 5V-signaal dat Arduino kan lezen. De code wacht vervolgens op een van deze signalen en voert vervolgens de opdrachten uit naar de LED-strip met behulp van de FastLED-bibliotheek. Dat is de basis, nu om in de details te komen.

Benodigdheden

Dit zijn de dingen die ik gebruikte omdat ik ze voor het grootste deel al had liggen. Uiteraard kunnen ze indien nodig worden uitgewisseld:

1. Arduino - Ik heb een nano gebruikt vanwege de grootte, maar je kunt alles gebruiken waar je zin in hebt, zolang je maar vijf pinnen hebt.
2. 5V-regelaar - Ik gebruikte een L7805CV die in staat was tot 1,5 ampère. Dit project gebruikt 0,72 ampère voor de LED's plus de stroom voor de nano, dus 1,5 werkt prima voor dit project.
3. Condensatoren - je hebt één 0,33 uF en één 0,1 uF nodig om de spanningsregelaar goed te laten werken.
4. 3x opto-isolators - om de signaalconversie van 12V naar 5V te doen. Ik gebruikte het PC817X-type dat slechts vier pinnen heeft en dat is alles wat we nodig hebben.
5. Weerstanden - je hebt twee typen nodig, drie van elk type. De eerste moet voldoende zijn om de stroom door de opto-isolator IR LED te verminderen. Je hebt minimaal 600 ohm nodig, maar 700 zou een beter idee zijn om veranderende spanningen op de motorfiets aan te kunnen. De andere moet ergens tussen 10k en 20k zijn voor een snel signaal aan de andere kant van de opto-isolator.
6. Prototypebord - Ik had er een paar die klein genoeg waren om in een kleine projectdoos te passen met een kleine hoeveelheid bijgesneden.
7. Projectdoos - groot genoeg om de componenten in te passen, maar klein genoeg om gemakkelijk te monteren.
8. Draad - Ik gebruikte Cat 6 ethernetdraad omdat ik er veel van had. Dit heeft acht draden, allemaal met een kleurcode, wat hielp bij alle verschillende verbindingen en was groot genoeg om de huidige trekkingen aan te kunnen.
9. Stekkers - overal waar u wilt dat het systeem eenvoudig kan worden verwijderd. Ik heb een waterdichte plug gebruikt om de topkoffer te kunnen verwijderen en om regen of water dat erop komt te kunnen opvangen. Ik had ook kleinere pluggen nodig voor de LED-strips, zodat ik geen grote gaten hoefde te boren.
10. Ritssluitingen en zelfklevende sluitingen om alles op zijn plaats te houden.
11. Krimpfolie om de verbindingen op te ruimen.

Stap 1: Het circuit bouwen

Als je mijn build volgt, hoef je natuurlijk niet zoveel te testen als ik heb gedaan. Het eerste wat ik deed, was ervoor zorgen dat mijn code werkte en dat ik een signaal van de opto-isolators goed kon krijgen en de LED-strips goed kon bedienen. Het duurde even om erachter te komen hoe ik de signaalpinnen het beste aan de isolatoren kon bevestigen, maar met vallen en opstaan vond ik de juiste oriëntatie. Ik heb gewoon een standaard prototypebord gebruikt, omdat ik er maar één aan het bouwen was en het uitzoeken van een sporenpatroon meer tijd zou hebben gekost dan het waard was. Het bovenste deel van de printplaat ziet er geweldig uit, maar de onderkant ziet er een beetje rommelig uit, maar het is in ieder geval functioneel.

Het basisontwerp begint met het invoeren van de 12V-stroom van een geschakelde bron (een draad die alleen aan is als de motorfiets aan staat). Een bedradingsschema kan echt helpen om deze draad te vinden. Dit wordt aan één kant van de spanningsregelaar ingevoerd. Een condensator van 0,33 uF verbindt deze ingang met de aarde op de spanningsregelaar, die vervolgens terugkoppelt naar de aarde op de motorfiets. De uitgang van de spanningsregelaar heeft een condensator van 0,1 uF die met aarde is verbonden. Deze condensatoren helpen om de spanning van de regelaar af te vlakken. Als je ze niet kunt vinden op de afbeelding van de printplaat, dan zitten ze onder de spanningsregelaar. Van daaruit gaat de 5V-lijn naar de Vin op de Arduino, naar de power-pin die de LED-strips zal voeden, en twee naar de Source-kant van de opto-isolator die de Arduino-pinnen zal voeden die het benodigde 5V-signaal leveren.

Wat betreft de opto-isolatoren, er zijn twee kanten: een met een IR-LED en de andere met een transistor met en IR-detector. We willen de IR LED kant gebruiken om het 12V signaal te meten. Omdat de LED een voorwaartse spanning van 1,2 V heeft, hebben we een stroombegrenzende weerstand in serie nodig. 12V - 1,2V = 10,8V en om de LED op 18 mA te laten werken (ik wil altijd minder dan 20 mA gebruiken vanwege levenslange redenen), heb je een weerstand van R = 10,8V/0,018A = 600 ohm nodig. Spanningen op voertuigen hebben ook de neiging om hoger te lopen, mogelijk tot 14V, dus het is beter om daar rekening mee te houden, wat ongeveer 710 ohm is, hoewel 700 meer dan redelijk zou zijn. De uitgang voor de LED-zijde wordt dan teruggekoppeld naar aarde. Voor de uitgangszijde van de opto-isolator gebruikt de ingang het 5V-signaal van de regelaar, waarna de uitgang verbinding maakt met een andere weerstand voordat deze naar aarde gaat. Deze weerstand moet gewoon rond de 10k - 20k ohm zijn, althans dat is wat mijn datasheet liet zien. Dit geeft een snelle signaalmeting omdat we niet te maken hebben met een lawaaierige omgeving. De uitgang naar de Arduino-pin komt los tussen de weerstand en de uitgang van de opto-isolator, zodat wanneer het signaal uit is, de pin laag is en wanneer het signaal op de pin hoog is.

De LED-striplampen hebben drie bijbehorende draden: stroom, aarde en data. Stroom moet 5V zijn. Dit project gebruikt in totaal 12 LED's (hoewel ik meer LED's op de strips heb, maar ik gebruik slechts elke derde LED) en elk kost 60 mA wanneer wit licht op volledige helderheid wordt gebruikt. Dit geeft een totaal van 720 mA. We zitten ruim binnen het uitgangsvermogen van de spanningsregelaar, dus we zitten goed. Zorg er wel voor dat de draad groot genoeg is om de stroom aan te kunnen, ik gebruikte 24 gauge Cat 6 ethernetdraad. Ethernet-draad was iets dat ik had en het heeft 8 kleurgecodeerde draden, dus het werkte goed voor dit project. De enige draden die dan naar de topbox zelf moeten gaan, zijn de stroom en aarde (die beide worden gesplitst tussen de strips) en twee datalijnen (één voor elke strip).

De rest van de bedrading maakt verbinding met de pinnen op de Arduino en voedt deze van stroom. De pinnen die voor dit project werden gebruikt waren de volgende:

1. Vin - aangesloten op 5V
2. Gnd - verbonden met aarde
3. Pin2 - aangesloten op linker strip datalijn
4. Pin3 - aangesloten op de rechter strip datalijn
5. Pin4 - aangesloten op remsignaal van de opto-isolator
6. Pin5 - aangesloten op linker richtingaanwijzer van de opto-isolator
7. Pin6 - aangesloten op rechter richtingaanwijzer van de optoisolator

Stap 2: Bedrading en installatie

Zodra het circuit is gebouwd, komt het tijd om dit daadwerkelijk op zijn plaats te bedraden. Met behulp van uw bedradingsschema voor uw fiets, moet u het volgende vinden:

• Geschakelde voeding
• Grond
• Remsignaal In
• Richtingaanwijzer links in
• Richtingaanwijzer rechts in

Voor de mijne was er een enkele plug met al deze erop, dus die heb ik gewoon gebruikt. Met genoeg tijd had ik misschien dezelfde plug-stijl kunnen vinden en gewoon een plug-in-module kunnen maken, maar dat deed ik niet, dus ik heb de isolatie op sommige plaatsen verwijderd en de nieuwe draad eraan gesoldeerd. Ik gebruikte pluggen op deze gesplitste verbindingen, zodat ik de rest kon verwijderen als ik dat in de toekomst ooit nodig zou hebben. Van daaruit plaatste ik de Arduino, die nu in een afgesloten projectdoos zit, onder de stoel waar ik hem heb bevestigd. De uitgangskabel loopt dan langs het rackframe naar een waterdichte plug, gaat dan de doos in en loopt langs de achterkant naar het deksel waar het voor elke kant splitst. De draden lopen langs de binnenkant van het deksel naar het punt waar de aansluitingen voor de LED's zitten. De draad wordt op zijn plaats gehouden met behulp van ritssluitingen die zijn bevestigd aan ritssluitingen van buitenkwaliteit met een zelfklevende achterkant. Je kunt deze vinden in het gedeelte over kabelinstallatie in een bouwmarkt

Ik heb twee mini-JST-stekkers op de LED-strips gebruikt omdat ik een stekker nodig had die klein genoeg was om door een gat met een minimale diameter te gaan en omdat ik er zeker van wilde zijn dat er genoeg draad was om aan de huidige vereisten te voldoen. Nogmaals, het was misschien overdreven en ik had geen kleine stekkers met drie draden bij de hand. Het gat in de doos waar de draden van de lichtstrip doorheen moesten, waren afgedicht om water buiten te houden. Wat betreft het positioneren van de LED-strips, omdat er een kleine mismatch is in de afstand (er was ongeveer 1 - 1,5 mm verschil in afstand tussen de gaten in de reflector en de LED's), heb ik ze zo geplaatst dat ze het verschil tussen de LED en het gat zoveel mogelijk. Vervolgens heb ik hete lijm gebruikt om ze op hun plaats te hechten en afdichtmiddel om het gebied volledig af te dichten. De ledstrips zelf zijn waterdicht, dus geen probleem als ze nat worden. Hoewel het veel lijkt om te installeren, maakt dit het systeem gemakkelijker om in de toekomst te verwijderen of onderdelen te vervangen omdat het zou kunnen gebeuren.

Stap 3: De code

Mijn broncode moet aan het begin van deze Instructable staan. Ik geef altijd veel commentaar op mijn code, zodat het later gemakkelijker te begrijpen is. Disclaimer: ik ben geen professionele codeschrijver. De code is geschreven in een methode die gemakkelijker was om eerst aan de slag te gaan en er zijn enkele verbeteringen aangebracht, maar ik weet dat het verfijnder zou kunnen zijn. Ik gebruik ook een groot deel van de delay()-functie voor timing, wat niet zo ideaal is. De signalen die het apparaat ontvangt zijn in vergelijking echter geen snelle signalen, dus ik voelde me nog steeds gerechtvaardigd om ze te behouden met zoiets als millis(). Ik heb ook een erg drukke vader en echtgenoot, dus tijd besteden aan het verbeteren van iets dat de functie uiteindelijk niet zal veranderen, staat niet hoog op de lijst.

Voor dit project is slechts één bibliotheek nodig, namelijk de FastLED-bibliotheek. Dit heeft alle code voor het aansturen van de WS2811/WS2812B type LED-strips. Van daaruit zal ik de basisfuncties behandelen die zullen worden gebruikt.

De eerste andere dan de standaarddefinities is het declareren van uw twee strips. Voor elke strip gebruikt u de volgende code:

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

Deze coderegel stelt Pin 2 in, definieert deze strip als strip 0 met het aantal LED's gedefinieerd door de constante NUM_LEDS, die in mijn geval is ingesteld op 16. Om de tweede strip te definiëren, wordt de 2 3 (voor pin3) en de strip krijgt het label strip 1.

De volgende regel die belangrijk zal zijn, is kleurdefinitie.

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

Deze regel code wordt echter in verschillende looks gebruikt (de meeste van mijn gebruik een constante). Kortom, deze code stuurt een waarde naar elk van de LED-kanalen (rood, groen, blauw) die elke helderheid definieert. De helderheidswaarde kan worden gedefinieerd door een getal 0 - 255. Door het helderheidsniveau voor elk kanaal te wijzigen, kunt u verschillende kleuren definiëren. Voor dit project wil ik een witte kleur om het licht zo helder mogelijk te houden. Dus de enige veranderingen die ik doe, is om het helderheidsniveau voor alle drie de kanalen hetzelfde in te stellen.

De volgende set code wordt gebruikt om elk licht afzonderlijk te verlichten. Merk op dat voor elke strip elke LED een adres heeft dat begint bij 0 voor degene die zich het dichtst bij de datalijnverbinding bevindt tot aan het hoogste nummer dat je hebt min 1. Voorbeeld, dit zijn 16 LED-strips, dus de hoogste is 16 - 1 = 15. De reden hiervoor is dat de eerste LED het label 0 heeft.

for (int i = NUM_LEDS-1; i > -1; i = i - 3) {// Dit verandert het licht voor elke derde LED van de laatste naar de eerste. leds[0] = Kleur_laag; // Stel strip 0 LED-kleur in op de gekozen kleur. leds[1] = Kleur_laag; // Stel strip 1 LED kleur in op de gekozen kleur. FastLED.show(); // Toon de ingestelde kleuren. leds[0] = CRGB::Zwart; // Zet de ingestelde kleur uit in de voorbereiding voor de volgende kleur. leds[1] = CRGB::Zwart; vertraging (150); } FastLED.show(); // Toon de ingestelde kleuren.

De manier waarop deze code werkt, is dat een variabele (i) wordt gebruikt binnen een for-lus als het LED-adres dat vervolgens wordt verwezen naar het volledige aantal LED's (NUM_LEDS). De reden hiervoor is dat ik wil dat de lichten aan het einde van de strip beginnen in plaats van aan het begin. De instelling wordt uitgevoerd naar beide strips (leds[0] en leds[1]), waarna een commando wordt gegeven om de wijziging aan te geven. Daarna gaat dit lampje uit (CRGB::Black) en gaat het volgende lampje branden. De zwarte referentie is een specifieke kleur in de FastLED-bibliotheek, dus ik hoef geen 0, 0, 0 voor elk kanaal uit te geven, hoewel ze hetzelfde zouden doen. De For-lus gaat 3 LED's tegelijk vooruit (i = i-3) omdat ik alleen elke andere LED gebruik. Aan het einde van deze lus gaat de lichtsequentie van de ene LED naar de andere met slechts één aangestoken per strip, een soort Knight Rider-effect. Als je elk lampje wilt laten branden zodat de balk wordt opgebouwd, verwijder je gewoon de lijnen die de LED's uitzetten, wat gebeurt in de volgende reeks code in het programma.

for (int i = 0; i <dim; i++) {// Laat lichten snel vervagen naar looplichtniveau. rt = rt + 1; gt = gt + 1; bt = bt + 1; for (int i = 9; i <NUM_LEDS; i = i +3) { // Hierdoor gaan de laatste drie lichten voor het positielicht branden. leds[0] = CRGB(rt, gt, bt); // Stel strip 0 LED-kleur in op de gekozen kleur. leds[1] = CRGB(rt, gt, bt); // Stel strip 1 LED kleur in op de gekozen kleur. } FastLED.show(); vertraging (3); }

Het laatste voorbeeld van code die ik gebruik voor de LED's is een fade-loop. Hier gebruik ik tijdelijke slots voor de helderheid voor elk kanaal (rt, gt, bt) en verhoog ik ze met 1 met een vertraging tussen elke weergave om het uiterlijk te krijgen dat ik wil. Merk ook op dat deze code alleen de laatste drie LED's verandert, omdat dit in de looplichten vervaagt, dus ik begin bij 9 in plaats van 0.

De rest van de LED-code zijn herhalingen hiervan. Al het andere is gericht op het zoeken naar een signaal op de drie verschillende draden. Het Loop()-gebied van de code zoekt naar remlichten, die één keer knipperen voordat hij blijft branden (dit kan desgewenst worden aangepast) of naar richtingaanwijzers zoekt. Voor deze code, omdat ik niet kon aannemen dat de linker en rechter richtingaanwijzers op precies dezelfde tijd zouden branden voor gevaren, laat ik de code eerst naar een van beide zoeken, en na een kleine vertraging controleer ik of beide aan staan de alarmlichten branden. Het enige lastige deel dat ik had, waren richtingaanwijzers omdat het licht een tijdje uitgaat, dus hoe kan ik het verschil zien tussen het signaal dat nog aan is maar in de uit-periode en een geannuleerd signaal? Wat ik bedacht was het implementeren van een vertragingslus die is ingesteld om langer door te gaan dan de vertraging tussen signaalflitsen. Als de richtingaanwijzer nog steeds aan is, gaat de signaallus verder. Als het signaal niet terugkomt wanneer de vertraging eindigt, gaat het terug naar het begin van de lus(). Om de lengte van de vertraging aan te passen, wijzigt u het nummer voor de constante lightDelay onthoud voor elke 1 in lightDelay de vertraging verandert met 100ms.

while (digitalRead(leftTurn) == LAAG) { for(int i = 0; i <lightDelay; i++) { leftTurnCheck(); if(digitalRead(leftTurn) == HOOG) { leftTurnLight(); } vertraging(100); } for (int i = 0; i <NUM_LEDS; i = i +3) { // Dit verandert het licht voor elke derde LED van de laatste naar de eerste. leds[0] = CRGB(0, 0, 0); // Stel strip 0 LED-kleur in op de gekozen kleur. } for (int i = 9; i <NUM_LEDS; i = i +3) { // Hiermee worden de looplichten ingesteld die alleen de laatste drie gebruiken. leds[0] = Kleur_laag; // Stel strip 0 LED-kleur in op de gekozen kleur. } FastLED.show(); // Uitvoerinstellingen terugkeren; // Zodra de richtingaanwijzer niet meer aan is, gaat u terug naar de lus. }

Hopelijk spreekt de rest van de code voor zich. Het is gewoon een herhalende reeks van controleren en reageren op signalen.

Stap 4: Resultaten

Het verbazingwekkende was dat dit systeem werkte de eerste keer dat ik het op de fiets bekabelde. Nu, om eerlijk te zijn, heb ik het vooraf zwaar op de bank getest, maar ik verwachtte nog steeds een probleem of een aanpassing. Blijkt dat ik geen aanpassingen aan de code en de verbindingen hoefde aan te brengen. Zoals je in de video kunt zien, gaat het systeem door de opstartvolgorde (die je niet hoeft te hebben), en gaat dan standaard over op running lights. Daarna zoekt het naar de remmen, in welk geval het alle LED's op volle sterkte zal oplichten en ze één keer zal knipperen voordat het aan blijft totdat de remmen worden losgelaten. Wanneer een richtingaanwijzer wordt gebruikt, heb ik een scrollend effect gemaakt voor de kant waar de afslag wordt aangegeven en de andere kant zal ofwel looplicht zijn of remlicht indien aan. Alarmlichten knipperen net op tijd met de andere lichten.

Hopelijk ben ik met deze extra lichten beter zichtbaar voor andere mensen. Het is op zijn minst een leuke toevoeging om mijn box iets meer te laten opvallen dan andere, terwijl het toch bruikbaar is. Ik hoop dat dit project ook nuttig is voor iemand anders, zelfs als ze niet werken met een motorfiets-topkofferverlichting. Bedankt!