instructables

DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals

by geckostudios

As a motorcycle rider, I'm all too familiar with being treated like I'm invisible on the road. One thing I always add to
my bikes is a top box which usually has an integrated light. I recently upgraded to a new bike and bought the Givi
V56 Monokey box since it had lots of space for items. This box has a spot for a factory light kit which consists of
two strips of LEDs for each side. The problem is this kit is about $70 and only does brakes. There is an aftermarket
kit that probably does similar things and might be a bit easier to install, but your price goes up to $150. Being a
resourceful person and looking for an excuse to try out the addressable LED strips, I decided to make an
integrated system that not only would have brake lights, but running lights (on whenever moving), turn signals, and
hazard lights. Just for the heck of it, I even added a startup sequence.... because I could. Note that this took a lot
of work to do though I had a lot of things to figure out. Despite the work, I'm rather happy with how this turned out.
Hopefully this ends up being useful to someone else.

The basic operation of how this system works is the Arduino unit looks for signals on the pins: brake light, left turn
light, and right turn light. In order to read the 12 volt signal from the motorcycle, I used optoisolators to convert the
12V signal to a 5V signal that Arduino can read. The code then waits for one of these signals then outputs the
commands to the LED strip using the FastLED library. That's the basics, now to get into the details.

Supplies:
These are the things that I used because for the most part I already had them lying around. Obviously, they can be
exchanged out as needed:

1. Arduino - I used a nano for size considerations but you can use whatever you feel like as long as
you have five pins to use.
2. 5V regulator - I used an L7805CV that was capable of 1.5 amps. This project will use 0.72 amps for
the LEDs plus the power for the nano, so 1.5 works great for this project.
3. Capacitors - you will need one 0.33 uF and one 0.1 uF for the voltage regulator to operate properly.
4. 3x optoisolators - to do the signal conversion from 12V to 5V. I used PC817X type which only have
four pins which is all we need.
5. Resistors - you will need two types, three of each type. The first needs to be enough to reduce the
current through the optoisolator IR LED. You will need at least 600 ohm, but 700 would be a better
idea to handle changing voltages on the motorcycle. The other needs to be somewhere between
10k and 20k for a quick signal on the other side of the optoisolator.
6. Prototype board - I had some that were small enough to fit inside a small project box with a slight
amount of trimming.
7. Project box - big enough to fit the components, but small enough to be easy to fit.
8. Wire - I used Cat 6 ethernet wire because I had a lot of it sitting around. This has eight wires all
color coded which helped with all the different connections and was a large enough gauge to handle
the current draws.
DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 1
 9. Plugs - anywhere you want the system to be easily removable. I used a waterproof plug to allow the
top box to be removed and to handle any rain or water that gets on it. I also needed smaller plugs
for the LED strips so I didn't have to drill large holes.
10. Zip ties and zip tie adhesive mounts to hold everything in place.
11. Shrink wrap to tidy up the connections.

https://youtu.be/xtSzXwfG3HA

Download
https://www.instructables.com/ORIG/FLV/QH1C/JX8T7JMQ/FLVQH1CJX8T7JMQ.ino
…

DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 2
Step 1: Building the Circuit

Obviously, if you're following my build, you won't have to go through the amount of testing I did. First thing I did
was to make sure my code worked and I could properly get a signal from the optoisolators as well as properly
control the LED strips. It took a moment to figure out how best to attach the signal pins to the isolators but through
trial and error I found the right orientation. I just used a standard prototype board since I was only building one and
figuring out a trace pattern would have taken more time than it was worth. The top part of the circuit board looks
great, but the bottom does look like a bit of a mess, but at least it's functional.

The basic design starts with inputting the 12V power from a switched source (a wire that is only on when the
motorcycle is on). A wiring diagram can really help to find this wire. This is fed into one side of the voltage
regulator. A 0.33 uF capacitor ties this input to the ground on the voltage regulator which then feeds back to the
ground on the motorcycle. The output of the voltage regulator will have a 0.1uF capacitor tied into it to ground.
These capacitors help to smooth out the voltage from the regulator. If you can't find them in the picture of the
circuit board, they are underneath the voltage regulator. From there, the 5V line goes to the Vin on the Arduino, to
the power pin that will feed the LED strips, and two the Source side of the optoisolator that will feed into the
Arduino pins providing the needed 5V signal.

As for the optoisolators, there are two sides: one with an IR LED and the other with a transistor with and IR
detector. We want to use the IR LED side to measure the 12V signal. Since the LED has a forward voltage of
1.2V, we need a current limiting resistor in series. 12V - 1.2V = 10.8V and to run the LED at 18 mA (I always like
to run less than 20 mA for lifetime reasons), you will need a resistor of R = 10.8V/0.018A = 600 ohm. Voltages on
vehicles also tend to run higher, potentially up to 14V, so it's better to plan for that, which is about 710 ohm, though
700 would be more than reasonable. The output for the LED side then feeds back to ground. For the output side of
the optoisolator, the input will use the 5V signal from the regulator then the output will connect to another resistor
before going to ground. This resistor just needs to be around 10k - 20k ohm, at least that's what my datasheet
showed. This will give a quick signal measurement since we're not dealing with a noisy environment. The output to
the Arduino pin will come off between the resistor and the output of the optoisolator so that when the signal is off
the pin is low and when the signal is on the pin is high.

The LED strip lights have three wires associated with them: Power, ground, and data. Power needs to be 5V. This
project uses 12 LEDs total (though I have more LEDS on the strips but I'm only using every third LED) and each
takes 60mA when white light is used at full brightness. This gives a total of 720 mA. We're well within the output
power for the voltage regulator, so we're good. Just make sure that the wire is a large enough gauge to handle the
power, I used 24 gauge Cat 6 ethernet wire. Ethernet wire was something that I had sitting around and it has 8
color coded wires so it worked out well for this project. The only wires that then need to go to the topbox itself is
the power and ground (which both get split between the strips) and two data lines (one for each strip).

The rest of the wiring is connecting to the pins on the arduino and feeding it power. The pins that were used for this
project were the following:

1. Vin - connected to 5V
2. Gnd - connected to ground
3. Pin2 - connected to Left strip data line
4. Pin3 - connected to Right strip data line
5. Pin4 - connected to Brake signal from the optoisolator
6. Pin5 - connected to Left turn signal from the optoisolator
7. Pin6 - connected to Right turn signal from the optoisolator

DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 3
DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 4
Step 2: Wiring and Installing

Once the circuit is built, the time comes to actually wire this into place. Using your wiring schematic for your bike,
you will need to locate the following:

Switched power supply

Ground
Brake Signal In
Left Turn Signal In
Right Turn Signal In

For mine, there was a single plug that had all of these on it, so I just used that. With enough time, I might have
been able to find the same plug style and just make a plug in module, but I didn't, so I just removed the insulation
in places and soldered the new wire to it. I used plugs on these spliced connections so that I could remove the rest
should I ever need to in the future. From there I placed the Arduino, which is now in a sealed project box, under the
seat where I attached it. The output cable then runs along the rack frame to a waterproof plug, then enters the box
and runs along the back to the lid where it splits for each side. The wires run along the inside of the lid to the point
where the connections for the LEDs are at. The wire is help in place using zip ties attached to Outdoor grade zip
tie mounts with an adhesive backing. You can find these in the cable installation section at a home improvement
store

I used two mini JST plugs on the LED strips because I needed a plug small enough to go through a hole of
minimum diameter and because I wanted to make sure there was enough wire to handle the current requirements.
Again, it may have been overkill and I didn't have any small plugs with three wires handy. The hole in the box for
the light strip wires to pass through were sealed up to keep water out. As for positioning the LED strips, because
there is a slight mismatch in spacing (there was about 1 - 1.5 mm difference in spacing between the holes in the
reflector and the LEDs) I positioned them so that they would split the difference between the LED and the hole as
much as possible. I then used hot glue to tack them in place and sealant to fully seal the area. The LED strips
themselves are waterproof, so no issue if they get wet. Although it seems like a lot to install, this makes the
system easier to remove in the future or replace parts are needed because it could happen.

DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 5
DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 6
Step 3: The Code

My source code should be at the beginning of this Instructable. I always comment my code heavily so it's easier to
understand later on. Disclaimer: I'm not a professional code writer. The code was written in a method that was
easier to get going first and some improvements were made, but I know it could be more refined. I'm also using a
heavy amount of the delay() function for timing which is not as ideal. However, the signals that the unit is receiving
are not fast signals in comparison, so I still felt justified to keep them over using something like millis(). I'm also a
very busy father and husband so spending time to improve something that will ultimately not change the function
isn't high on the list.

For this project, only one library is required which is the FastLED library. This has all the code for controlling the
WS2811/WS2812B type LED strips. From there, I'll cover the basic functions that will be used.

The first other than the standard definitions is to declare your two strips. You will use the following code for each
DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 7
strip:

FastLED.addLeds<WS2812B, 2,RGB>(leds[0], NUM_LEDS);

This line of code sets up Pin 2 defines this strip as strip 0 with the number of LEDs defined by the constant
NUM_LEDS, which in my case is set to 16. To define the second strip, the 2 will become 3 (for pin3) and the strip
will be labeled strip 1.

The next line that will be important is color definition.

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

This line of code is used though in different looks (most of my use a constant). Basically, this code sends a value
to each of the LED channels (red, green, blue) that defines each brightness. The brightness value can be defined
by a number 0 - 255. By changing the level of brightness for each channel, you can define different colors. For this
project, I want a white color to keep the light as bright as possible. So the only changes I do is to set the brightness
level the same across all three channels.

The next set of code is used for individually lighting each light. Note that for each strip, each LED has an address
that starts at 0 for the one closest to the data line connection all the way up to the highest number LED you have
minus 1. Example, these are 16 LED strips, so the highest is 16 - 1 = 15. The reason for this is because the first
LED is labeled 0.

for (int i = NUM_LEDS-1; i > -1; i = i - 3) { // This will change the light for every third LED going from the last to first.<br> leds[0][i] = Color_low; // Set str
ip 0 LED color to the chosen color.
leds[1][i] = Color_low; // Set strip 1 LED color to the chosen color.
FastLED.show(); // Show the set colors.
leds[0][i] = CRGB::Black; // Turn off set color in prep for next color.
leds[1][i] = CRGB::Black;
delay(150);
}
FastLED.show(); // Show the set colors.

The way this code works is that a variable (i) is used within a for loop as the LED address which is then referenced
to the full number of LEDs (NUM_LEDS). The reason for this is that I want the lights to start at the end of the strip
rather than the beginning. The setting is output to both strips (leds[0] and leds[1]) then a command to show the
change is issued. After that this light is turned off (CRGB::Black) and the next light is lit. The Black reference is a
specific color in the FastLED library so I don't have to issue 0,0,0 for each channel though they would do the same
thing. The For loop advances 3 LEDs at a time (i = i-3) since I'm only using every other LED. By the end of this
loop, the light sequence will go from one LED to the next with only one lit per strip, sort of a Knight Rider effect. If
you want to keep each light lit so that the bar builds, you would just remove the lines that turn the LEDs off which
happens in the next set of code in the program.

for (int i = 0; i < dim; i++) { // Quickly fade lights to running light level. <br> rt = rt + 1;
gt = gt + 1;
bt = bt + 1;
for (int i = 9; i < NUM_LEDS; i = i +3) { // This will light up the last three lights for the position light.
leds[0][i] = CRGB( rt, gt, bt); // Set strip 0 LED color to the chosen color.
leds[1][i] = CRGB( rt, gt, bt); // Set strip 1 LED color to the chosen color.
}
FastLED.show();
delay(3);
}

The last example of code that I use for the LEDs is a fade loop. Here, I use temporary slots for the brightness for

DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 8
each channel (rt, gt, bt) and increment them by 1 with a delay between each showing to achieve the appearance I
want. Also note that this code is only changing the last three LEDs as this is fading in the running lights so i starts
at 9 rather than 0.

The rest of the LED code is iterations of these. Everything else is focused around looking for a signal on the three
different wires. The Loop() area of the code looks for brake lights, which it will flash once before staying on (this is
adjustable if desired) or looking for turn signals. For this code, because I couldn't assume the left and right turn
lights would turn on exactly the same time for hazards, I have the code look for either one first, then after a small
delay I check to see if both are on indicating the hazard lights are on. The one tricky part I had was turn signals
because the light will go out for some period so how do I tell the difference between the signal still on but in the off
period and a cancelled signal? What I came up with was implementing a delay loop that is set to continue longer
than the delay between signal flashes. If the turn signal is still on, then the signal loop will continue. If the signal
does not come back on when the delay ends, then it goes back to the start of the loop(). To adjust the length of the
delay, change the number for the constant lightDelay remembering for every 1 in lightDelay the delay changes by
100ms.

while (digitalRead(leftTurn) == LOW) { for(int i = 0; i < lightDelay; i++) {

leftTurnCheck();
if(digitalRead(leftTurn) == HIGH) {
leftTurnLight();
}
delay(100);
}
for (int i = 0; i < NUM_LEDS; i = i +3) { // This will change the light for every third LED going from the last to first.
leds[0][i] = CRGB( 0, 0, 0); // Set strip 0 LED color to the chosen color.
}
for (int i = 9; i < NUM_LEDS; i = i +3) { // This will set up the running lights which only use the last three.
leds[0][i] = Color_low; // Set strip 0 LED color to the chosen color.
}
FastLED.show(); // Output settings
return; // Once turn signal is no longer on, go back to loop.
}

Hopefully the rest of the code is self explanatory. It's just a repeating set of checking and acting upon signals.

Step 4: Results

The amazing part was that this system worked the
first time I wired it to the bike. Now, to be fair I heavily
tested it on the bench prior to this, but I still expected
to have an issue or an adjustment. Turns out that I
didn't need to make any adjustments to the code as
well as the connections. As you can see in the video,
the system goes though the startup sequence (which
you don't have to have), then defaults into running
lights. After that it looks for the brakes in which case it
will light up all LEDs to full brightness and flash them
once before remaining on till the brakes are released.
When a turn signal is used, I made a scrolling effect
for the side that the turn is indicated and the other
side will be either running lights or brake light if on.
Hazard lights will just blink in time with the other
lights.
Hopefully with these additional lights, I will be more
visible to other people. At the very least, it's a nice
addition to make my box stand out a bit more than
others while providing utility. I hope this project is
useful to someone else as well even if they are not
working with a motorcycle top box lighting. Thanks!

DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 9
This is one that I WILL be building later this year! Thank you for posting a truly useful Instructable.

You're welcome! As I said, there are versions that you can purchase, but there's something nice
about making it yourself. Plus you can get it to behave how you want. Good luck with the build.
It's great to see custom solutions like this. Nicely done, and great first instructable too!

Thanks for the comment! It's nice to have learning experiences.

DIY Givi V56 Motorcycle Topbox Light Kit With Integrated Signals: Page 10