DIY Givi V56 Topbox Light Kit met motorfiets met geïntegreerde seine: 4 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:25

As 'n motorfietsryer is ek alte bekend dat ek behandel word asof ek onsigbaar is op die pad. Een ding wat ek altyd by my fietse voeg, is 'n boks met 'n geïntegreerde lig. Ek het onlangs opgegradeer na 'n nuwe fiets en die Givi V56 Monokey -boks gekoop, aangesien dit baie ruimte vir items het. Hierdie boks het 'n plek vir 'n fabrieksligstel, wat bestaan uit twee stroke LED's aan elke kant. Die probleem is dat hierdie kit ongeveer $ 70 kos en slegs remme doen. Daar is 'n aftermarket -stel wat waarskynlik soortgelyke dinge doen en miskien 'n bietjie makliker is om te installeer, maar u prys styg tot $ 150. Omdat ek 'n vindingryke persoon was en op soek was na 'n verskoning om die aanspreekbare LED -stroke te probeer, het ek besluit om 'n geïntegreerde stelsel te maak wat nie net remligte het nie, maar ook ligte (brand wanneer dit beweeg), rigtingwysers en gevaarligte. Ek het selfs 'n opstartvolgorde bygevoeg …. omdat ek kon. Let op dat dit baie werk nodig was, alhoewel ek baie dinge moes uitvind. Ten spyte van die werk, is ek nogal tevrede met hoe dit afgeloop het. Hopelik sal dit nuttig wees vir iemand anders.

Die basiese werking van hoe hierdie stelsel werk, is dat die Arduino -eenheid na seine op die penne kyk: remlig, draai links en regs. Om die 12 volt sein van die motorfiets af te lees, gebruik ek optoisolators om die 12V sein om te skakel na 'n 5V sein wat Arduino kan lees. Die kode wag dan op een van hierdie seine en voer dan die opdragte uit na die LED -strook met behulp van die FastLED -biblioteek. Dit is die basiese beginsels om nou in die besonderhede in te gaan.

Voorrade

Dit is die dinge wat ek gebruik het, want ek het dit meestal al laat rondlê. Uiteraard kan hulle soos nodig uitgeruil word:

1. Arduino - ek het 'n nano gebruik vir grootte oorwegings, maar u kan alles gebruik, solank u vyf penne moet gebruik.
2. 5V -reguleerder - ek het 'n L7805CV gebruik wat 1,5 ampère kon uitvoer. Hierdie projek gebruik 0.72 ampère vir die LED's plus die krag vir die nano, dus 1.5 werk uitstekend vir hierdie projek.
3. Kondensators - u benodig een 0.33 uF en een 0.1 uF om die spanningsreguleerder behoorlik te laat funksioneer.
4. 3x optoisolators - om die seinomskakeling van 12V na 5V te doen. Ek het 'n PC817X -tipe gebruik, wat net vier penne het, en dit is al wat ons nodig het.
5. Weerstande - jy benodig twee tipes, drie van elke tipe. Die eerste moet genoeg wees om die stroom deur die optoisolator IR LED te verminder. U benodig ten minste 600 ohm, maar 700 sou 'n beter idee wees om veranderende spannings op die motorfiets te hanteer. Die ander een moet tussen 10k en 20k wees vir 'n vinnige sein aan die ander kant van die optoisolator.
6. Prototipe bord - ek het 'n paar wat klein genoeg was om in 'n klein projektiekas te pas, met 'n bietjie snoei.
7. Projekkas - groot genoeg om by die komponente te pas, maar klein genoeg om maklik te pas.
8. Draad - ek het Cat 6 -ethernetdraad gebruik omdat ek baie daarvan sit. Dit het agt drade met alle kleurkodes, wat gehelp het met al die verskillende verbindings en 'n groot genoeg meter was om die huidige trekkings te hanteer.
9. Stekkers - oral waar u wil hê dat die stelsel maklik verwyderbaar is. Ek het 'n waterdigte prop gebruik om die boonste boks te verwyder en om reën of water wat daarop kom, te hanteer. Ek het ook kleiner proppe vir die LED -stroke nodig, sodat ek nie groot gate hoef te boor nie.
10. Ritsbande en gomsteunings met rits om alles op sy plek te hou.
11. Krimp wrap om die verbindings op te ruim.

Stap 1: Bou die kring

As u my opset volg, hoef u natuurlik nie die hoeveelheid toetse wat ek gedoen het, te ondergaan nie. Die eerste ding wat ek gedoen het, was om seker te maak dat my kode werk en dat ek 'n sein van die optoisolators kan kry, sowel as om die LED -stroke behoorlik te beheer. Dit het 'n rukkie geneem om uit te vind hoe om die seinpennetjies die beste aan die isolators vas te maak, maar deur proef en fout het ek die regte oriëntasie gevind. Ek het pas 'n standaard prototipe -bord gebruik, aangesien ek net een gebou het en 'n spoorpatroon sou uitvind sou meer tyd geneem het as wat dit die moeite werd was. Die boonste gedeelte van die printplaat lyk pragtig, maar die onderkant lyk effens gemors, maar dit is ten minste funksioneel.

Die basiese ontwerp begin met die invoer van die 12V -krag van 'n skakelaar ('n draad wat slegs aan is as die motorfiets aan is). 'N Bedradingsdiagram kan regtig help om hierdie draad te vind. Dit word aan die een kant van die spanningsreguleerder gevoer. 'N 0,33 uF -kondensator verbind hierdie inset met die grond op die spanningsreguleerder wat dan op die motorfiets na die grond terugvoer. Die uitset van die spanningsreguleerder sal 'n 0.1uF kapasitor aan die aarde vasgemaak hê. Hierdie kapasitors help om die spanning van die reguleerder glad te maak. As u dit nie op die prentjie van die printplaat kan vind nie, is dit onder die spanningsreguleerder. Van daar af gaan die 5V -lyn na die Vin op die Arduino, na die kragpen wat die LED -stroke voed, en twee aan die bronkant van die optoisolator wat in die Arduino -penne ingevoer word, met die nodige 5V -sein.

Wat die optoisolators betref, is daar twee kante: een met 'n IR -LED en die ander met 'n transistor met en IR -detektor. Ons wil die IR LED -kant gebruik om die 12V -sein te meet. Aangesien die LED 'n voorspanning van 1.2V het, benodig ons 'n stroombeperkende weerstand in serie. 12V - 1.2V = 10.8V en om die LED op 18 mA te laat werk (ek hou altyd van minder as 20 mA om lewenslange redes), benodig u 'n weerstand van R = 10.8V/0.018A = 600 ohm. Die spanning op voertuie is ook geneig om hoër te loop, moontlik tot 14V, dus dit is beter om te beplan, wat ongeveer 710 ohm is, alhoewel 700 meer as redelik sou wees. Die uitset vir die LED -kant voer dan terug na die grond. Vir die uitsetkant van die optoisolator gebruik die ingang die 5V -sein van die reguleerder, en dan sal die uitset aansluit by 'n ander weerstand voordat dit grond toe gaan. Hierdie weerstand moet ongeveer 10k - 20k ohm wees, ten minste is dit wat my datablad gewys het. Dit gee 'n vinnige seinmeting, aangesien ons nie te doen het met 'n raserige omgewing nie. Die uitset na die Arduino -pen sal tussen die weerstand en die uitset van die optoisolator afgaan, sodat die pen laag is en die sein hoog is wanneer die sein af is.

Die LED -strookligte het drie drade wat daarmee verband hou: krag, grond en data. Krag moet 5V wees. Hierdie projek gebruik in totaal 12 LED's (alhoewel ek meer LED's op die stroke het, maar ek gebruik slegs elke derde LED) en elk neem 60mA wanneer wit lig op volle helderheid gebruik word. Dit gee 'n totaal van 720 mA. Ons is goed binne die uitsetvermoë van die spanningsreguleerder, so ons is goed. Maak net seker dat die draad 'n groot genoeg meter is om die krag te hanteer; ek het 'n 24 -meter Cat 6 -ethernetdraad gebruik. Ek het 'n ethernetdraad gehad, en ek het 8 gekleurde drade, so dit het goed uitgewerk vir hierdie projek. Die enigste drade wat dan na die boks self moet gaan, is die krag en die grond (wat albei tussen die stroke verdeel word) en twee datalyne (een vir elke strook).

Die res van die bedrading sluit aan op die penne op die arduino en voed dit met krag. Die penne wat vir hierdie projek gebruik is, was die volgende:

1. Vin - gekoppel aan 5V
2. Gnd - gekoppel aan die grond
3. Pin2 - gekoppel aan die linkerstrook -datalyn
4. Pin3 - gekoppel aan die regte strook -datalyn
5. Pin4 - gekoppel aan die remsein van die optoisolator
6. Pin5 - gekoppel aan linkerwyser van die optoisolator
7. Pin6 - gekoppel aan die rigtingwyser van die optoisolator

Stap 2: Bedrading en installering

Sodra die kring gebou is, is dit tyd om dit in plek te sit. Deur u bedradingskema vir u fiets te gebruik, moet u die volgende opspoor:

• Skakel kragbron
• Grond
• Remsein in
• Draai seine na links
• Draai sein regs in

Vir myne was daar 'n enkele prop wat dit alles bevat, so ek het dit net gebruik. Met genoeg tyd kon ek moontlik dieselfde plug -styl vind en net 'n plug -in -module maak, maar ek het dit nie gedoen nie, so ek het net die isolasie plek -plek verwyder en die nuwe draad daaraan gesoldeer. Ek het proppe op hierdie verbindings gebruik, sodat ek die res kan verwyder as ek ooit in die toekoms sou nodig wees. Van daar af het ek die Arduino, wat nou in 'n verseëlde projekkas is, onder die sitplek geplaas waar ek dit vasgemaak het. Die uitgangskabel loop dan langs die rekraam na 'n waterdigte prop, gaan dan in die boks en loop langs die agterkant na die deksel waar dit vir elke kant verdeel word. Die drade loop langs die binnekant van die deksel tot by die punt waar die verbindings vir die LED's is. Die draad word gehelp met behulp van ritsbande wat vasgemaak is aan die buitenste ritssluiting met 'n kleefsteun. U kan dit vind in die kabelinstallasie -afdeling by 'n huisverbeteringswinkel

Ek het twee mini JST -proppe op die LED -stroke gebruik omdat ek 'n prop nodig het wat klein genoeg is om deur 'n gat met 'n minimum deursnee te kom en omdat ek seker wil maak dat daar genoeg draad is om aan die huidige vereistes te voldoen. Weereens, dit was miskien te veel en ek het geen klein proppies met drie drade byderhand nie. Die gat in die boks waar die drade van die ligstrook deurloop, is toegemaak om water uit te hou. Wat die posisionering van die LED -stroke betref, want daar is 'n geringe afwyking in die spasiëring (daar was ongeveer 1 - 1,5 mm verskil tussen die gate in die reflektor en die LED's), sodat ek die verskil tussen die LED en die gat soveel as moontlik. Ek gebruik dan warm gom om dit op hul plek vas te plak en seëlaar om die gebied heeltemal te verseël. Die LED -stroke self is waterdig, dus dit is geen probleem as hulle nat word nie. Alhoewel dit baie lyk om te installeer, is dit makliker om die stelsel in die toekoms te verwyder of om dele te vervang, want dit kan gebeur.

Stap 3: Die kode

My bronkode moet aan die begin van hierdie instruksies wees. Ek lewer altyd kommentaar op my kode, sodat dit later makliker is om te verstaan. Disclaimer: Ek is nie 'n professionele kode skrywer nie. Die kode is op 'n metode geskryf wat makliker was om eers aan die gang te kom en 'n paar verbeterings is aangebring, maar ek weet dat dit meer verfyn kan word. Ek gebruik ook 'n groot hoeveelheid vertragings () -funksie vir tydsberekening, wat nie so ideaal is nie. Die seine wat die eenheid ontvang, is egter nie vinnige seine in vergelyking nie, dus was ek steeds geregverdig om dit oor te hou deur iets soos millis () te gebruik. Ek is ook 'n baie besige vader en eggenoot, so ek spandeer tyd om iets te verbeter wat uiteindelik nie die funksie sal verander nie, is nie hoog op die lys nie.

Vir hierdie projek is slegs een biblioteek nodig, die FastLED -biblioteek. Dit bevat al die kode vir die beheer van die WS2811/WS2812B tipe LED -stroke. Van daar af behandel ek die basiese funksies wat gebruik gaan word.

Die eerste behalwe die standaard definisies is om jou twee stroke te verklaar. U sal die volgende kode vir elke strook gebruik:

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

Hierdie kodereël stel Pin 2 op om hierdie strook as strook 0 te definieer met die aantal LED's gedefinieer deur die konstante NUM_LEDS, wat in my geval op 16. Om die tweede strook te definieer, word die 2 3 (vir pin3) en die strook sal strook 1 wees.

Die volgende reël wat belangrik sal wees, is kleurdefinisie.

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

Hierdie kode word egter in verskillende voorkoms gebruik (die meeste van my is konstant). Hierdie kode stuur basies 'n waarde na elk van die LED -kanale (rooi, groen, blou) wat elke helderheid definieer. Die helderheidswaarde kan gedefinieer word deur 'n getal 0 - 255. Deur die helderheidsvlak vir elke kanaal te verander, kan u verskillende kleure definieer. Vir hierdie projek wil ek 'n wit kleur hê om die lig so helder as moontlik te hou. Die enigste veranderinge wat ek doen, is om die helderheidsvlak oor al drie kanale dieselfde te stel.

Die volgende stel kode word gebruik om elke lig individueel aan te steek. Let daarop dat elke LED vir elke strook 'n adres het wat begin by 0 vir die een wat die naaste aan die data -lynverbinding is, tot by die hoogste nommer LED wat u minus 1. Byvoorbeeld, dit is 16 LED -stroke, dus die hoogste is 16 - 1 = 15. Die rede hiervoor is omdat die eerste LED 0 is.

for (int i = NUM_LEDS -1; i> -1; i = i -3) {// Dit verander die lig vir elke derde LED van die laaste na die eerste. leds [0] = Kleur laag; // Stel strook 0 LED -kleur in op die gekose kleur. leds [1] = Kleur laag; // Stel strook 1 LED -kleur in op die gekose kleur. FastLED.show (); // Toon die stel kleure. leds [0] = CRGB:: Swart; // Skakel die gekleurde kleur uit voor die volgende kleur. leds [1] = CRGB:: Swart; vertraging (150); } FastLED.show (); // Toon die stel kleure.

Die manier waarop hierdie kode werk, is dat 'n veranderlike (i) binne 'n for -lus as die LED -adres gebruik word, waarna daarna verwys word na die volle aantal LED's (NUM_LEDS). Die rede hiervoor is dat ek wil hê dat die ligte eerder aan die einde van die strook as aan die begin moet begin. Die instelling word na beide stroke (leds [0] en leds [1]) uitgevoer, en dan word 'n opdrag gegee om die verandering aan te toon. Daarna word hierdie lig afgeskakel (CRGB:: Swart) en die volgende lig brand. Die swart verwysing is 'n spesifieke kleur in die FastLED -biblioteek, so ek hoef nie 0, 0, 0 vir elke kanaal uit te gee nie, alhoewel hulle dieselfde sou doen. Die For-lus vorder 3 LED's op 'n slag (i = i-3), aangesien ek slegs elke ander LED gebruik. Aan die einde van hierdie lus gaan die ligvolgorde van een LED na die volgende, met slegs een verligte per strook, 'n soort Knight Rider -effek. As u elke lig wil laat brand sodat die balk bou, verwyder u net die lyne wat die LED's uitskakel, wat in die volgende stel kode in die program gebeur.

for (int i = 0; i <dim; i ++) {// Vervaag ligte vinnig tot lopende ligvlak. rt = rt + 1; gt = gt + 1; bt = bt + 1; for (int i = 9; i <NUM_LEDS; i = i +3) {// Dit sal die laaste drie ligte vir die posisioneringslig verlig. leds [0] = CRGB (rt, gt, bt); // Stel strook 0 LED -kleur in op die gekose kleur. leds [1] = CRGB (rt, gt, bt); // Stel strook 1 LED -kleur in op die gekose kleur. } FastLED.show (); vertraging (3); }

Die laaste voorbeeld van kode wat ek vir die LED's gebruik, is 'n vervaaglus. Hier gebruik ek tydelike gleuwe vir die helderheid van elke kanaal (rt, gt, bt) en verhoog dit met 1 met 'n vertraging tussen elke vertoning om die voorkoms te kry wat ek wil hê. Let ook daarop dat hierdie kode slegs die laaste drie LED's verander, aangesien dit in die ligte vervaag, sodat ek by 9 begin eerder as 0.

Die res van die LED -kode is herhalings hiervan. Al die ander fokus daarop om 'n sein op die drie verskillende drade te soek. Die Loop () -gedeelte van die kode soek na remligte, wat dit een keer sal flikker voordat dit aangeskakel word (dit is verstelbaar indien nodig) of op soek na rigtingwysers. Omdat ek vir hierdie kode nie kon aanvaar dat die linker- en regterligte presies dieselfde tyd sou brand vir gevare nie, het ek eers na die kode gesoek, en na 'n klein vertraging kyk ek of beide aan is om aan te dui die gevaarligte is aan. Die enigste moeilike deel wat ek gehad het, was rigtingwysers, want die lig gaan vir 'n geruime tyd uit, hoe kan ek die verskil sien tussen die sein wat nog steeds aan is, maar in die af -tydperk en 'n gekanselleerde sein? Wat ek bedink het, was die implementering van 'n vertragingslus wat langer sal duur as die vertraging tussen seinflitse. As die rigtingaanwyser steeds aan is, sal die seinslus voortgaan. As die sein nie weer opkom as die vertraging eindig nie, gaan dit terug na die begin van die lus (). Om die lengte van die vertraging aan te pas, verander die getal vir die konstante lightDelay onthou vir elke 1 in lightDelay verander die vertraging met 100ms.

terwyl (digitalRead (leftTurn) == LOW) {for (int i = 0; i <lightDelay; i ++) {leftTurnCheck (); as (digitalRead (leftTurn) == HOOG) {leftTurnLight (); } vertraging (100); } vir (int i = 0; i <NUM_LEDS; i = i +3) {// Dit verander die lig vir elke derde LED van die laaste na die eerste. leds [0] = CRGB (0, 0, 0); // Stel strook 0 LED -kleur in op die gekose kleur. } vir (int i = 9; i <NUM_LEDS; i = i +3) {// Dit stel die ligte op wat slegs die laaste drie gebruik. leds [0] = Kleur laag; // Stel strook 0 LED -kleur in op die gekose kleur. } FastLED.show (); // Uitsetinstellings terug; // Sodra die rigtingaanwyser nie meer aangeskakel is nie, gaan terug na die lus. }

Hopelik is die res van die kode vanselfsprekend. Dit is net 'n herhalende reeks om na seine te kyk en op te tree.

Stap 4: Resultate

Die wonderlike deel was dat hierdie stelsel gewerk het die eerste keer dat ek dit aan die fiets gekoppel het. Om eerlik te wees, het ek dit vooraf op die bank getoets, maar ek het steeds verwag dat ek 'n probleem of aanpassing sou hê. Dit blyk dat ek nie die kode sowel as die verbindings hoef aan te pas nie. Soos u in die video kan sien, gaan die stelsel deur die opstartvolgorde (wat u nie hoef te hê nie), en word dan standaard in lopende ligte. Daarna soek dit na die remme, in welke geval dit alle LED's tot volle helderheid sal verlig en een keer flits voordat dit aanhou totdat die remme loskom. As 'n rigtingaanwyser gebruik word, het ek 'n blaai -effek gemaak vir die kant dat die draai aangedui word, en die ander kant sal óf loopligte óf remlig wees as dit aan is. Gevaarligte flikker net betyds saam met die ander ligte.

Hopelik sal ek met hierdie ekstra ligte meer sigbaar wees vir ander mense. Dit is ten minste 'n goeie toevoeging om my boks 'n bietjie meer te laat uitstaan as ander terwyl dit nut bied. Ek hoop dat hierdie projek ook vir iemand anders nuttig is, selfs al werk hulle nie met 'n motorfiets -boks nie. Dankie!