I had a retired playfield that I used for some experiments with clear-coating and after few too many experiments it was pretty much done. However, I didn't want to throw it away so I decided to make it into some wall art. I know some folks just hang them up or even put Christmas lights in them but I decided I wanted to be able to program a real light display just like a pinball machine.

I did a bunch of research here on Pinside and elsewhere and was surprised how hard it was to do. I thought going in it would be simple but there are actually some real technical challenges. The ways that pinball makers solved this problem with a lamp matrix and clock cycle is really interesting but very hard to replicate. The main problem is you need a switch and I/O for each bulb and at ~75 bulbs that is a real challange. However, we live in a modern world and someone has developed individually programmable LEDs that can be tied together without any switches on one I/O port. You can drive this easily with a simple microprocessor such as an Arduino Uno. I am not an electrical engineer or adept at microprocessors so I suspect there are a bunch other and maybe way better ways to do this but this gets the job done.

So for anyone who also wants to do this but wants to skip all the research and puzzling things out I thought I would lay out in detail how I did it.

The good news is it is actually pretty easy and not terribly expensive but does require a lot of wiring and mounting of LEDS.

So first off here is a link to a video of the final product showing three sequences I came up with:

Every insert is fully programmable for color and intensity. The GIs are also programable but all on the same circuit (i.e. they all do the same thing). You don't have to do this for the GIs but making them separate is even more wiring. But basically you can make any sequence you can imagine and even replicate the actual attract mode or game play on your machine (this would require a fair amount of patience).

Here is a picture of the back side to show the wiring.

0513211348 (resized).jpg

Also I added some fake plastic in front of the GI and added some pop bumper caps to the playfield as well to give it some depth:

0514211721 (resized).jpg

Next the parts list...

So here is the parts list:

1ea - Arduino Uno or clones (just google this one)

50-100ea - Programmable LEDs (here are the ones I used https://www.amazon.com/gp/product/B06XN66ZY6/ref=ppx_yo_dt_b_search_asin_title). You need them to be bulbs not strips. This brand fits perfectly into my GI holes so I recommend them.

Small wire - https://www.amazon.com/gp/product/B07G2GLKMP/ref=ppx_yo_dt_b_search_asin_title

Optional - Good wire strippers (there are a lot of wires to strip) - https://www.amazon.com/Jonard-Tools-WS-822-Stripper-Stranded/dp/B07WYK6XY4 or others

Good Solder Gun with Temp Control - I worked at 650degrees F

General wire for mounting - I used malleable wire for fences was .06" diameter. Probably get this at the hardware store.

Power supply - So each bulb needs .3W or 30W/100 bulbs. I needed 80 bulbs total for mine. So you will need something like a 12v/2.5A power supply. Mine is kind of overkill so you can look around for something reasonable on amazon or digikey.

Next is the LED theory...

So each LED has six total wires and a microchip:

0514211731a (resized).jpg

There are three wires in and three out. Confusingly they are all black but the outside one has a white stripe:

Inked0514211855 (1)_LI (resized).jpg

The outside solid black is + and the outside white strip is - and the center is the signal wire.

There is also a front or input side:

0514211902 (resized).jpg

And an output side:

0514211902a (resized).jpg

So basically you need to connect every LED to + and - (front and back doesn't matter for power). The easiest way to do this is to do them in "Series", so you jump from one to the next. However, because of the microchip they are not actually in a series circuit. The signal wire must be in series from first to last bulb going from input to output side.

Inked0514211907_HDR_LI (resized).jpg

So the cool thing is that you can keep them in a string if you have room or cut them apart. The only thing that matters is that the signal wire sequentially goes from each bulb from input to output. This is how the software numbers them. The first bulb in the series is [0] and then the next is [1]. It doesn't matter if you cut them apart and wire them differently.

So the next part is not hard but you have to do it like 80 times so it is by far the most time consuming.

For mounting, I created these little loops for mounting over inserts. I found a 1/2 inch dowel and drilled a small hole perpendicular in the dowel the size of the wire. I then inserted the end of the wire and wrapped it around the dowel. I then cut the bit of wire in the dowel with side cutters and got a nice clean loop. I then finished the other end with a needle nose to create a small loop for a screw. Make sure you keep the small loop in the direction you tighten the screw.

0514211731 (resized).jpg

You can then mount this on each LED and position it on the playfield above each insert:

0514211923 (resized).jpg

For the GIs on my playfield (Whirlwind) they fit almost perfectly in the GI holes and I just used some hot-glue to secure them.

0514211926 (resized).jpg

So for wiring the first thing is to connect all the bulbs to power (+,-). I thought it would be easier to use crimp butt connectors but they were not very reliable and I was having to redo them too many times. I then switched to just soldering them all. I thought this would be harder but in fact it was much easier. Once you get the hang of it you get really good and the connections are rock-solid. I then just cut some heat shrink to insulate them.

Inked0514211927a_LI (resized).jpg

Because almost all of these connections will be in series if you make a mistake it might be hard to trouble shoot. What I did was connect my multimeter to the first connection and put it on audible beep on connection. Then after every connection I would check it was still connected.

The next step is to connect the signal wires which is somewhat harder. The first thing to consider is what order you want them. The first signal wire will go from the Arduino output (I used #5) to the input side (front) of the first bulb. This will be designated LED [0] by the software. Then you need to connect from the output of the first bulb to the input of the next bulb which will be [1]. If you want to assign all the GIs individually then they will be no different than any other but it will be a lot more wiring and programming. I chose to have all the GIs assigned to a single bulb. So in my specific example I had 58 insert LEDs and I assigned LED[59] as the GI.

Unfortunately this next part is a little confusing but I will try to be clear. So in my case my last insert LED was [58]. So I took the output signal from [58] to the input of the nearest GI. I then wired the INPUT of that GI to the INPUT of the next GI. Basically I never used the output wire of any GI LED but just keep jumping from input to input. This means that every GI will "think" it is LED[59]. Once you connect to an output it would increment the bulb to [60] which we don't want. Hope that makes sense. In this picture you can see that I have two wires into the Input of this GI and the Output is simply cut:

Inked0514211927_LIa (resized).jpg

So to wire the Arduino it is really simple. You just need to take the output from a I/O, I used #5 and that is the start of your signal wire which goes to LED[0] input. For some reason I don't understand, you also need a resistor. I can't remember the rating but you can read the stripes in the pictures. Maybe some kind person can say what it is:

0514212004 (resized).jpg

Also, you need to wire the ground from the power supply to the ground of the Arduino. Again, I am not sure why but I think it completes the signal circuit somehow (again not an electrical guy...). The power for the Arduino comes from the USB connectors which is either in your computer during programming or in a phone style charger.

Inked0514211736_LI (resized).jpg

And that is basically it for wiring.

One final note is that there is no conductivity between the input and the output of the signal wires. When I was wiring them up I was concerned if I was wiring them correctly and there was no way to check with a multimeter. What I did was actually make a simple program in the Arduino that cycled through the bulbs and I had it running when I wired the signal wires then I could see if they were turning on or not. It is low voltage so it didn't seem like much on issue to wire it live.

The easiest mistake to make is to wire to the output instead of the input or vice-versa. The only way to check is to look closely at each side of the LED and for the GIs I went through and cut the exposed output wire on all of them so I wouldn't get confused.

Next step is programming....

So again, this is just me making something that worked. I didn't want to become an Arduino expert, just have something that hangs from the wall. Here is an explanation of what to do if you know nothing about Arduino. I am not anything close to competent in this software. I can only tell you the basics.

First, download the software:

https://www.arduino.cc/en/software

Then you need to create a sketch. There are a bunch of libraries related to LEDS that you can use to start with.

If you message me I am happy to send you my program.

A couple of basics I learned:

"//" in front of any line is a comment and will not be seen by the program

To define a variable it needs to be in all CAPS followed by a value like:

#define DELAY1 100

There are three basic sections:

1 - Defining variables and such

2 - Setup which defines the LEDS which looks like this.

void setup() {

FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS);
}

For some reason I don't understand, the LEDs I recommended are supposed to be WS2811 but it doesn't work but does under WS2812B.

3 - Program, everything inside this (and only that inside this) will run forever:

void loop() {

....program

}

Here is what it looks like:

Screenshot 2021-05-14 203627 (resized).png

Inside the "void loop ()" you can make "for loops" which control various things, in this step I have a For Loop which cycles this sequence 3x and then the loop which drives the sequence:

// Vertical Wipe
// Number of Cycles
for(int i=0; i<3; i++){
// Loop to cycle lights
for(int i=0; i<359; i++){
leds[0] = CHSV(0, 0, 255*pow(sin(3.1415*(i+0)/180),POWER));
leds[13] = CHSV(0, 0, 255*pow(sin(3.1415*(i+40)/180),POWER));
}
}

In a For Loop, int i=0 sets the initial value, i<3 sets the maximum number (when it stops), and i++ just increments it by 1 each time.

The key command to light an LED is in two steps. The first step is to assign values to 1 or more LEDS which is done like this:

leds[59] = CHSV(0, 0, 180);

or

leds[59] = CRGB(180, 180, 180);

CHSV is Hue-Saturation-Value and RGB is Red-Green-Blue. The maximum value for all setting is 255, so the brightest white in each is:

leds[59] = CHSV(0, 0, 255);
leds[59] = CRGB(255, 255, 255);

You can use either but HSV is actually easier because most of what you are doing is likely changing value which requires changing 3 values in RBG but only 1 in HSV. Here is guide for HSV:

gCNJp (resized).jpg

The second part in lighting the leds is:

FastLED.show();

So basically you set the value of 1 or more LEDs with the led[x] command and then issue the FastLED command which sends the signal down the line to all the LEDs. Keep in mind that the actual LEDs will stay in whatever level was set before (even if you unplug the Arduino). They don't need constant commands to stay lit. In fact you need to turn them off. For instance, this a sequence that sequentially turns LEDs off and on:

leds[15] = CHSV(0, 0, 255);
FastLED.show();
delay(500);
leds[15] = CHSV(0, 0, 0);
FastLED.show();
delay(500);

leds[14] = CHSV(0, 0, 255);
FastLED.show();
delay(500);
leds[14] = CHSV(0, 0, 0);
FastLED.show();
delay(500);

So this simple sequence is turning on leds[15] to maximum value, waiting for 500ms, then turning it off. It waits again for 500ms, turns on leds[14] etc...

If you are patient you could program any sequence with this method but it takes a long time. I think it is a good idea to set both the brightness and delay as standard variables, if you want to globally change them it is easy:

#define DELAY2 500
#define INBRIGHT 255

...

leds[15] = CHSV(0, 0, INBRIGHT);
FastLED.show();
delay(DELAY2);
leds[15] = CHSV(0, 0, 0);
FastLED.show();
delay(DELAY2);

leds[14] = CHSV(0, 0, INBRIGHT);
FastLED.show();
delay(DELAY2);
leds[14] = CHSV(0, 0, 0);
FastLED.show();
delay(DELAY2);

One method I used which was much easier was to use the sin function to vary the brightness in a For Loop:

// Rotating Sin
// Number of Cycles
for(int i=0; i<3; i++){ -This Sets a loop which finishes after 3x
// Loop to cycle lights
for(int i=0; i<359; i++){ -This sets a loop which cycles from 0 to 359 or 1 circle

// GIs
leds[59] = CHSV(0, 0, 255*pow(sin(3.1415*(i+90)/180),POWER)); -This varies the GI brightness by the value of Sin (0-1) offset by 90 degrees from 0

// Lower Inserts CCW
leds[16] = CHSV(0, 0, 255*pow(sin(3.1415*(i+75)/180),POWER));
leds[15] = CHSV(0, 0, 255*pow(sin(3.1415*(i+60)/180),POWER));
leds[14] = CHSV(0, 0, 255*pow(sin(3.1415*(i+45)/180),POWER));
leds[13] = CHSV(0, 0, 255*pow(sin(3.1415*(i+30)/180),POWER));
leds[12] = CHSV(0, 0, 255*pow(sin(3.1415*(i+15)/180),POWER));
leds[11] = CHSV(0, 0, 255*pow(sin(3.1415*(i+0)/180),POWER));

And that is about it for what I did. If you want you could brute-force one LED at a time or add in some more advanced features.

So I think that is everything I can think of. I spent longer on this than I wanted but am happy I finished. I hope I can save other people sometime in figuring this out. Comment below or message me if you want any other information.

Yeah it would have been nice to restore it back to like-new but I was really using it to try some techniques out and I learned a bunch. I got to try the Auto Clear Coat in a can which was good and some other things but there were eventually just too many different layers to sand down.

That would be very cool but way beyond my abilities. Also it would be tricky because it would have to be flexible enough to deal with any playfield layout.

Just another note, it is a little confusing to keep track of the numbers of each bulb. What I did was a run a little program that would light led 1-10 and then on the front of the playfield I marked them with masking tape. I then repeated it for 11-20 etc. Then I had marks on all the bulb on the front and I just programmed in front of it to keep track of the numbers.

0514211714_HDR (resized).jpg

Also, I never mentioned how you load the program onto the Arduino. You write the software in the program you downloaded and you connect the Arduino to your computer through a USB (laptop is ideal for this). Then at the top of the screen on your computer is an upload button which stops the Arduino and replaces whatever was on it with the new program. As far as I know the Arduino only ever has one program. When you are done you simply unplug the USB and plug it back into some kind of power supply (like for a phone charger) and it will run that program forever.

Looks great but yeah, the wiring takes a long time. There are way more bulbs than you think.

What did you use for mounting? Looks better than my wire system.

Looks great.

How did you do your butt-splices on your wires? I just twisted and soldered but then you have a dead-end. I couldn't find a fast way to splice end-to-end.

Looks awesome, well done.

Looks awesome, I love the metal frame

Looks great

This was such a struggle for me to get to a final product and I am so impressed with everything people have done beyond my efforts. However I was just thinking how great it was that my WW "un-usable" playfield had a second life. It is really cool to see these old playfield live again.