A Simple 5x7 NeoPixel Display

In the early 60's Hasbro took advantage of the growing interest in "computers" to sell a cleverly packaged trivia game called Think-a-Tron. Before you can begin to understand how Think-a-Tron works, you need to see it actually running. This video does a great job of explaining how to operate a Think-a-Tron.

I'm in the process of making a Think-a-Tron workalike. For more details about this project see: Think-a-Tron 2020.

This Instructable is about just one of the elements on the original Think-a-Tron that I wished to capture with some fidelity, the 5x7 "LED" display. I was surprised to learn that this display was purely mechanical! This was accomplished by shining a light trough a spinning disk (seen above) onto a 5x7 array of plastic lenses. It was a great effect. Very clever.

My 2020 implementation takes advantage of modern, individually-addressable, RGB color pixels. This is a pretty simple build so let's get started.

In addition to the printed parts you will need:

• BTF-LIGHTING 100pcs WS2812B Addressable 5050 Smart RGB LED Pixel Light on Black Heat Sink PCB Board for Arduino 5V DC - Amazon.ca
• Some 30 awg "wire wrapping" or similar wire.
• 4 M2 x 6mm bolts.

I printed the parts with the following settings (unless otherwise specified):

Print Resolution: .2 mm

Infill: 20%

Filament: AMZ3D PLA

Notes: No supports. Print the parts in their default orientation. To make a 5x7 NeoPixel Display you will need to print the following parts:

• 1 - LED Array Box
• 1 - LED Array Diffuser Note: It's all one piece, printed at .1 mm. I printed the black backing panel, paused the print at the 1.1 mm mark, then finished with some "transparent" PLA filament.

The panel on the original Think-a-Tron is 50 mm (2") wide and 70 mm (2 3/4") high and I wanted mine to be the same size. I searched for a suitably sized LED array but came up empty. I was about to start creating a custom PCB when I found some NeoPixel compatible, WS2812B addressable, smart RGB LED pixel lights. They are individual units but ship attached in a 10x10 grid as can be seen above. The good news for me is that each pixel light is about 10 mm in diameter which is perfect for my purposes.

With a little careful bending it was easy to snap off a 5x7 block of these. As shipped they are not connected so I had to wire the individual units in my 5x7 array together. I used some 30 awg "wire wrapping" wire that I had lying around from the old days ;-) It was a lot of pads to wire but not too hard. Use the second photo above as a wiring guide.

The pixel lights shipped with a three wire connector that I attached to the panel (photo 3).

1. Press the diffuser panel into the front of the display case with the "domes" facing forward.
2. Place the LED panel behind the diffuser with the LED lights facing forward, and the wire leads aligned with the slot in the case.
3. Use 4 M2 x 6 mm screws to attach the back of the display case.

For testing purposes I connected the display to an Arduino Nano:

• Red wire to +5V
• Green wire to the D6 input
• White wire to GND

I wrote a short sketch using the Arduino FastLED library.

#include "FastLED.h"

#define NUM_LEDS 35
#define LEDS_PIN 6
CRGB leds[NUM_LEDS];

int A[35] = {0,0,1,1,1,1,1,
             0,1,0,0,1,0,0,
             1,0,0,0,1,0,0,
             0,1,0,0,1,0,0,
             0,0,1,1,1,1,1};

int B[35] = {1,1,1,1,1,1,1,
             1,0,0,1,0,0,1,
             1,0,0,1,0,0,1,
             1,0,0,1,0,0,1,
             0,1,1,0,1,1,0}; 

int C[35] = {0,1,1,1,1,1,0,
             1,0,0,0,0,0,1,
             1,0,0,0,0,0,1,
             1,0,0,0,0,0,1,
             0,1,0,0,0,1,0};

int T[35] = {1,0,0,0,0,0,0,
             1,0,0,0,0,0,0,
             1,1,1,1,1,1,1,
             1,0,0,0,0,0,0,
             1,0,0,0,0,0,0};

int F[35] = {1,1,1,1,1,1,1,
             1,0,0,1,0,0,0,
             1,0,0,1,0,0,0,
             1,0,0,1,0,0,0,
             1,0,0,0,0,0,0};

void setup() {
  FastLED.addLeds<NEOPIXEL, LEDS_PIN>(leds, NUM_LEDS);
  Serial.begin(115200);
  Serial.println("5x7 LED Array");
  FastLED.setBrightness(32);

  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i] = CRGB::White;
    FastLED.show();
    delay (100); 
    leds[i] = CRGB::Black;
    FastLED.show();
  }
}

void loop() {
  showLetter(A);
  delay(1000);
  showLetter(B);
  delay(1000);
  showLetter(C);
  delay(1000);
  showLetter(T);
  delay(1000);
  showLetter(F);
  delay(1000);
  showRandom();
}

void showLetter(int letter[]) {

  for (int i = 0; i < NUM_LEDS; i++) {
    if (letter[i] == 1) {
      leds[i] = CRGB::White; 
    } else {
      leds[i] = CRGB::Black; 
    }
  }
  FastLED.show();
}

void showRandom() {
  for (int count = 0; count < 100; count++) {
    for (int i = 0; i < NUM_LEDS; i++) {
      if (random(3) == 0) {
        leds[i] = CRGB::Blue;
      } else {
        leds[i] = CRGB::Black; 
      }
    }
    FastLED.show();
    delay(50);
  }
}

I have a pretty specific use for this Display, but I hope you see that the same techniques can be applied to any sized pixel array projects.