How the Original Think-a-Tron Works

Before you can begin to understand how Think-a-Tron works, you need to see one actually running. This video does a great job of explaining how to operate a Think-a-Tron.

Having seen a Think-a-Tron in action, would you be surprised to learn that there are no active components? In fact, the only passive component is a single incandescent bulb powered by two D batteries! Think-a-Tron is actually a cleverly devised mechanical device. Let's see how it was done.

This is the back of the machine. The unit I purchased did not have a rear covering panel, but here is a photo of one.

What I had assumed would be some sort of early "electronic" 5x7 matrix display, was actually just a spinning disk. In hindsight this makes sense. In 1960, LEDs are still a couple of years away. Add many more years on top of that until they would be cheap enough to be used in a product like this. Using 35 incandescent bulbs would have been a nightmare. But a spinning disk, a single incandescent bulb, and some clever diffusers, that was ingenious. IMHO, the blinking light effect achieved as Think-a-Tron is "calculating" the answer, which we had come to associate with large mainframe computers in the 60's, was outstanding.

At the top, the blue box with the white "plug" holds the bulb.

Removing the bulb box we can see the first white diffuser panel on its bottom side.

This also gives us a better look at the wheel. You can make out the 5 "answers" A, B, C, T, and F, as well as some random holes in between used to help "sell" the blinking light effect. Also notice the spring used to tension the wheel when "cranked" from the front.

Removing the display wheel exposes the secondary diffuser panel into which a 5x7 matrix of clear lenses is embedded (which of course line up with the holes in the display wheel).

The white plate in the middle holds a central shaft in place. The crank handle in front of Think-a-Tron is connected to this shaft.

At the bottom, the blue box is a battery holder which is glued to the frame.

Behind the battery holder you can see the gears that make up the simple mechanical score counters. A downward press of the lever beside each of the two circular counters, turns the counting wheel clockwise, increasing the score by one .

This is what it the machine looks like with the shaft and plate removed. You can start to see a set of levers exposed.

And here is the shaft.

The crank handle is connected to the left side, and the display wheel to the right. Note the "bumps" sticking up from the central part of the shaft. We can see three of five answer tabs that are spaced equally both around the circumference, and the along the length, of the middle part of the shaft, to the left of a protruding ring. To the right of the ring you can see a single tab sticking up.

The "ridge" sticking up on the rightmost part of the shaft is "keyed" to a corresponding grove in the wheel's central hole.

Now here is where the magic happens. As was mentioned in the video, the question cards have notches corresponding to the correct answers. The circular holes and cut corner are just for show.

When a card is pushed into Think-a-Tron it will interact with the levers positioned beside the shaft.

You can see in the photo above, that four of the five "answer" levers are pushed away by the card, allowing only the center lever (corresponding to the answer A) to protrude. As the display wheel turns, the middle bump on the shaft for answer A will hit the protruding lever, stopping the wheel. The sixth "rightmost" lever locks the spring tensioned display wheel in place when it is cranked, and releases the wheel to spin freely to the correct answer when the card is pushed in. You can see the card tray's blue tab pushing the lever...

One More Thing
Michael Gardi • 02/04/2021 at 17:48 • 0 comments

I guess I was not quite done with the Think-a-Tron world just yet. This additional project was inspired by a part and was finished in under three days. Check it out here: Think-a-Tron Mini.

And here is a photo of my complete Think-a-Tron family.
Wrapping Up
Michael Gardi • 01/28/2021 at 16:14 • 0 comments
The hardware and software are finished and there is now an easy way to create trivia cards. Here is a video of Think-a-Tron 2020 in action.

Users read the trivia question from a card and "lock-in" their answers via the labeled push buttons. The card is then placed into the slot and the ? button pressed to tell Think-a-Tron to determine the correct answer. After a little thinking time (revealing the "man in the machine") the correct answer choice is displayed on the 5x7 pixel display and the players scores are updated. The answer selection buttons will turn green for a correct choice and red for a wrong pick. Pressing the ? again will reset Think-a-Tron for the next question. Pressing and holding the ? button for more than 5 seconds will reset the scores to 0.

When I look back at my goals for this project I think that I have accomplished at least two of the three.
1. I want to build something that is clearly a Think-a-Tron derivative. I'll let you be the judge, but I THINK there is a pretty good resemblance.
2. I would like to maintain the 60's mainframe vibe of the original. I don't think I nailed this one. Think-a-Tron 2020 doesn't scream 60's computer to me. Mind you I'm not unhappy with the look. I get a more 60's alien sci-fi computer vibe. I'm OK with this.
3. Have some fun along the way. You'll have to take my word for this one, but putting Think-a-Tron 2020 together was a blast.
Trivially Making Question Cards
Michael Gardi • 01/28/2021 at 03:15 • 0 comments
I'm relatively new to Python, but I'm beginning to appreciate how quickly you can get things done with it. What I thought might take a few days turned out to be more like a few hours.

So the application works with one sheet of Avery 5371 business cards at a time. You simply key in ten questions, choices, and answers then press the Save button. Three files will be created.
1. A text file with your data so that you can Load it back in to make changes.
```
['Humans and chimpanzees share roughly how much DNA?', 'Roughly how long does it take for the sun’s light to reach Earth ?', 'At what temperature are Celsius and Fahrenheit equal?', 'What modern-day country was Marie Curie born in?', 'How many hearts do octopuses have?', 'Apollo 15 was the first moon mission to carry a lunar rover?', 'On the periodic table, what symbol stands for silver?', 'Mercury is the only planet in the solar system without a moon.', 'What was the name of the first man-made satellite launched by the Soviet Union in 1957?', 'What is the biggest planet in our solar system?']
['10%', '8 minutes', '-40', 'Hungary', 'One', '', 'Si', '', 'Sputnik 1', 'Uranus']
['52%', '8 hours', '0', 'Poland', 'Two', '', 'Ag', '', 'Echo 1', 'Jupiter']
['98%', '8 days', '32', 'Czechoslovakia', 'Three', '', 'Na', '', 'Explorer 1', 'Neptune']
['', '', '', '', '', '', '', '', '', '']
['', '', '', '', '', '', '', '', '', '']
[3, 1, 1, 2, 3, 4, 2, 5, 1, 2] 
```
2. A PDF of the questions and choices nicely formatted one per card.
3. A PDF of the ten QR codes laid out to align with the correct questions when two sided printing.
It would be pretty easy to setup a trivia night with this program.

I did run into one issue creating this program. I'm using the ReportLab PDF Library to layout the cards (which works great by the way). My intention was to use the corresponding reportlab-qrcode library to generate the QR codes on the fly. I had thoughts or obfuscating the "payload" of each QR Code since if you look very closely at the QR Codes for simple "A", "B", "C", "T", and "F" payloads you can in fact distinguish between them.

Unfortunately the QR Code library I'm using on the ESP32 side would not read the generated codes. I tried many different variations but, in the end, decided to employ the QR Code images that I have been using all along. These images were created online at QR Code Generator.
It Worked!
Michael Gardi • 01/26/2021 at 02:03 • 0 comments

The ADS1115 did the trick. Not only did it get around my "one pin short" issue, the analog reads are now rock solid too.

I redid the "shield" incorporating the ADS1115 and everything works really well now. I consider the hardware to be officially complete at this point. I'm still tweaking the software a bit but that's pretty close too.

I have also started to write a Python script that will make the creation of trivia question cards, well, trivial. I see the light at the end of the tunnel.

For Want of a Pin the Project Remains Thus Far Unfinished

Michael Gardi • 01/23/2021 at 21:30 • 0 comments

I'm coming down to the wire, literally, for my Think-a-Tron 2020 project. The anticipation is killing me but I have a couple of small problems. For one I'm a pin short. I thought I was OK based on the documentation I had on hand. This was my plan.

ESP32-CAM PIN	Think-a-Tron 2020 Connection
GPIO 0	Not Available Camera XCLK
GPIO 1	Trigger Sound Effect
GPIO 2	Player 1 Answer Buttons (ADC)
GPIO 3	NeoPixels (all 45 of them)
GPIO 4	Camera LED
GPIO 12	Score Counters SDI
GPIO 13	Score Counters SCLK
GPIO 14	Player 2 Answer Buttons (ADC)
GPIO 15	Score Counters LOAD
GPIO 16	? Button ***

The problem is that GPIO 16 is in fact used by the Camera although this is not documented anywhere I could find. Any use of GPIO 16 causes the camera to crash when capturing an image (sigh).

The other issue is that the analog readings that I am getting from the player inputs suck. Even averaging multiple analog reads sometimes results in the wrong button being "selected".

So I have ordered a 16 bit high precision 4 channel I2C IIC Analog-to-Digital Converter based on the ADS1115 PGA ADC converter chip (Amazon).

So in a couple of days I'll see if I can convert two pins for an I2C bus into 3 inputs: Player1, Player2, and ? buttons. Hopefully I can kill two problems with one piece of silicon.

Wire Wrangling
Michael Gardi • 01/21/2021 at 17:17 • 0 comments

So with everything together I realized that I had to deal with a lot of wires.
If I were doing this again I would definitely put more thought into the whole wiring thing. But moving forward I need to try to to tame this mess. I decided to create a "shield" for the ESP32-CAM that would at least position the correct headers on the side that the wires were coming from.
Again if I could afford the shipping I would have made a PCB. As it is I'm getting lots of practice doing point-to-point wiring on proto boards for this project. I printed a card with the expected connections (which I assure you do line up with the pins when you don't have photo perspective issues). Here is the result.
A little better I think. I don't mind the showing what happens behind the curtains. So that's pretty much it for the hardware. Now to marry all of my little test sketches into a proper program for Think-a-Tron 2020.
A Second Sneak Peek
Michael Gardi • 01/17/2021 at 14:56 • 0 comments

While I was assembling the various pieces of Think-a-Tron 2020 it occurred to me that a wrap-around console look might be cool. This is what I ended up with.
Core Console
Michael Gardi • 01/17/2021 at 02:46 • 0 comments
The heart of Think-a-Tron 2020 consists of three main parts: the camera QR code reader section, the display, and the question (?) console with speaker.

The ESP32-CAM is mounted in a rectangular box forming the main part of the core section.

You can see there is a mounting slot for the ESP32-CAM and a guide to hold the question card (with QR code) at the correct distance for the camera to be able to read it. The top for this section has a slot that lines up with the guide to accept the card.

I had some buck converters lying around so I used one to power the project.

The power jack supplies the input voltage to the converter, with the output of 5V and GND connected o a small power rail that I made with headers and perf board. I mounted this with a small 3D printed bracket that I glued to the back.

I decided that I want to add a sound effect to the project so I purchased a cheap solid state recording and playback module (ISD1820 Sound Voice Recording Playback Module with Mic Sound Audio Microphone - Amazon).

I attached some jumper wires to the VCC, GND, and P-L connectors. Whatever you record on the device (which can hold about 10 seconds of sound) will play back so long as the P-L pin is held high).

There is a slot for the sound module on the opposite side of the card holder.

Run the jumpers along the left had side and out through the hole at the back as can be seen above. I secured the module with a piece of two sided tape.

I printed a small console to hold a single button and the speaker for the sound module.

I attached the printed speaker grill to the console front with a few dabs of glue. There are slots to mount the speaker, which I secured in place with some electrical tape. I attached leads to the push button common and NO pins.

Attach the speaker to the sound module and run the push button cables along the side and out the back the same as was done with the sound module. Attach the button panel to the console. Glue the console to the main part of the core section.

I printed a stand to hold the 5x7 NeoPixel display. I modified the wiring for the display case slightly so that the wires exited straight back instead of down.

Insert the display with case into the stand and glue the assembly to the top of main core section.

With everything assembled I wired the core unit up for a test.

Mounting the ESP32-CAM this way makes it easy to access the headers and more importantly the reset button. I wrote an little "integration" test to exercise the components that I just added to the core unit.
```
#include "Adafruit_NeoPixel.h"
#include "ESPino32CAM.h"
#include "ESPino32CAM_QRCode.h"

// Camera objects.
ESPino32CAM cam;   // Image capture object
ESPino32QRCode qr; // Image decoding object
 
// Set the camera pins.
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22

// Think-a-Tron Controls.
#define FLASH 4
#define SOUND 14
#define QUESTION 15


// 5x7 LED Array.
#define NUM_LEDS 35
#define LEDS_PIN 2
Adafruit_NeoPixel matrix(NUM_LEDS, LEDS_PIN, NEO_GRB + NEO_KHZ800);

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};

int Q[35] = {0,1,0,0,0,0,0,
             1,0,0,0,0,0,0,
             1,0,0,0,1,0,1,
             1,0,0,1,0,0,0,
             0,1,1,0...
```
Read more »
Sneak Peek
Michael Gardi • 01/12/2021 at 02:04 • 0 comments

While there is still a lot of wiring and integration work to do, I'd like to share a photo of what is probably the final design for Think-a-Tron 2020.

Ready Player One

Michael Gardi • 01/08/2021 at 19:17 • 0 comments

With all of the little bits sorted, I just finished the first major subassembly for Think-a-Tron 2020, the Player Console.

You'll notice something new in the picture above. A two digit seven-segment display that will be used to keep track of the player's score. I made five of the NeoPixel push button switches I talked about in my last log entry. The only change I made was to incorporate the switch leads into my header jack.

So from top to bottom we have:

+5V
Led In
Led Out
GND
Switch Common
Switch NO

I used a perf board with headers to help sort out the wiring. This Player Module also has the four 2K resistors used to determine which button is pressed. Point-to-point wiring was tight but doable. If I could get PCBs cheaply (it's the shipping to Canada that kills me), I would have gone that route.

I created a small slotted clamp to hold the Player Module perf board and attached it with two sided tape (or glue) to the back of a panel that I printed to mount the switches and display.

I added headers to the back of the seven-segment display (a Robojax Whmxe 595-2 74HC595 Driving 2 Digit 0.5in Seven Segment Display for Arduino - from Amazon) and mounted the display in the center rectangle with the raised edges. The front of the display should end up being flush with the front face of the panel. The switches are pushed in from the front of the panel and held in place with the tabs you can see in the second picture below.

I slid the perf board into the holder and began plugging in the switches.

Then I wired the Player Console to an Arduino Nano for a test.

Connect:

From	To
Player Module VCC	Arduino +5V
Player Module LEDS In	Arduino D6
Player Module GND	Arduino GND
SS Display VCC	Player Module VCC (Second Header)
SS Display GND	Player Module GND (Second Header)
SS Display SDI	Arduino D9
SS Display SCLK	Arduino D8
SS Display LOAD	Arduino D7

With everything attached mount the Player Panel onto the printed console seen below.

And the final result can be seen below running a small test sketch. The buttons are programmed to light when pressed and act as radio buttons so the only the last button pressed is illuminated. The counter was programmed to increment on each button press.

#include "FastLED.h"
#include <ShiftRegister74HC595.h>

#define SDI 9
#define SCLK 8
#define LOAD 7
#define DIGITS 2

// create shift register object (number of shift registers, data pin, clock pin, latch pin)
ShiftRegister74HC595 sr (DIGITS, SDI, SCLK, LOAD); 


int value,digit1,digit2,digit3,digit4; 
uint8_t  digits[] = {B11000000, //0
                      B11111001, //1 
                      B10100100, //2
                      B10110000, //3 
                      B10011001, //4
                      B10010010, //5
                      B10000010, //6 
                      B11111000, //7
                      B10000000, //8
                      B10010000 //9
                     };

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

int buttons = 0;

int A = 0;
int B = 1;
int C = 2;
int T = 3;
int F = 4;

int countA = 0;
int countB = 0;
int countC = 0;
int countT = 0;
int countF = 0;

int score = 0;

void setup() {
  Serial.begin(115200);
  Serial.println("Single LED");
  pinMode(A5, INPUT_PULLUP);
  
  FastLED.addLeds<NEOPIXEL, LEDS_PIN>(leds, NUM_LEDS);
  clearAnswers();
  FastLED.show();
}

void loop() {
  buttons = analogRead(5);
  Serial.println(buttons);
  
  if (buttons <= 24 && buttons >= 04) countA++;
  if (buttons <= 86 && buttons >= 66) countB++;
  if (buttons <= 134 && buttons >= 114) countC++;
  if (buttons <= 177 && buttons >= 157) countT++;
  if (buttons <= 215 && buttons >= 195) countF++;

  if (countA > 3) {showAnswer(A); FastLED.show(); waitForButtonUp(); score++; countA = 0; countB = 0; countC = 0; countT = 0; countF = 0;}
  if (countB > 3) {showAnswer(B); FastLED.show(); waitForButtonUp(); score++; countA = 0; countB = 0; countC = 0; countT = 0; countF = 0;}
  if (countC > 3) {showAnswer(C); FastLED.show(); waitForButtonUp(); score++; countA = 0; countB = 0; countC = 0; countT = 0; countF = 0;}
  if (countT > 3) {showAnswer(T); FastLED.show(); waitForButtonUp(); score++; countA = 0; countB = 0; countC = 0; countT = 0;...

View all 16 project logs

Think-a-Tron 2020

Description

Details

How the Original Think-a-Tron Works

Project Logs

Collapse

One More Thing

Wrapping Up

Trivially Making Question Cards

It Worked!

For Want of a Pin the Project Remains Thus Far Unfinished

Wire Wrangling

A Second Sneak Peek

Core Console

Sneak Peek

Ready Player One

Discussions

Similar Projects

Game-o-Tron Mini

Think-a-Tron Mini

Arduino Cat Training Console

LAMEBOY - another ESP12 handheld

Think-a-Tron 2020

Become a Hackaday.io member

Just one more thing

Description

Details

Project Logs Collapse

Enjoy this project?

Discussions

Become a Hackaday.io Member

Similar Projects

Does this project spark your interest?

Report project as inappropriate

Send message

Remove Member

Project Logs

Collapse