• A Second Sneak Peek

    Michael Gardi3 days ago 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 Gardi3 days ago 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 Gardi01/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 Gardi01/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:

    FromTo
    Player Module VCCArduino +5V
    Player Module LEDS InArduino D6
    Player Module GNDArduino GND
    SS Display VCCPlayer Module VCC (Second Header)
    SS Display GNDPlayer Module GND (Second Header)
    SS Display SDIArduino D9
    SS Display SCLKArduino D8
    SS Display LOADArduino 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;...
    Read more »

  • I Think the Answer Is... (Part 2)

    Michael Gardi01/03/2021 at 21:39 0 comments

    While the rotary switch turned out great, and certainly would have done the job, I think I'm going to go in a different direction for Think-a-Tron 2020. The key to this new concept is a push button. Not just any push button, but an illuminated push button, and not just any illumination, but WS2812B addressable, smart RGB LED pixel light illumination. It looks like this:

    There will be five of these per player, one for each answer choice A, B, C, T, or F.  When the player wants to "lock in" their answer, they just have to press the appropriate  button, and it will light up. The five will act as radio buttons, so only the last one pressed will ever be the illuminated choice. Since the LEDs can be any color, one can envision changing correct answers to green and incorrect answers to red after Think-a-Tron 2020 has declared the correct choice.  There are many blinkenlight possibilities.

    To be clear what I have here is a combination of a push button switch and an RGB addressable LED. They are not integrated in the sense that the switch controls the LED in any way, that's all done "centrally".

    Building a NeoPixel Push Button

    I started with a design that I used in my TMD-1 project for the panel buttons, and incorporated the same smart pixel units that I use for the 5x7 LED array. Here are all the parts you need to make one.

    So we are talking about a simple push button switch here that I built around a small micro switch (Amazon: Gikfun Micro Switch Long Hinge Lever (Pack of 20pcs) for Arduino EK1713) that I had lying around.  

    Assembly is pretty straight forward. Start by sliding the micro switch into the base piece making sure that the lever actuator does not extend past the edge of the base (there is one right and one wrong way to do this).

    Now attach the base piece to the bottom of the console mounting piece. Mine friction fit pretty good, but you can used a small amount of glue to hold it firmly in place if necessary. 

    Note the orientation of the hole in the bottom of the base and the slot in the side of the console mounting piece. This is important.

    Next slide the button shaft into the console mounting piece. Make sure that the slot on the button is aligned with the smaller slot at the top of the console mounting piece. Also make sure that the hole running down the shaft is aligned with the hole in the base.

    Prepare the single NeoPixel unit by attaching short wires to the +5V, GND, Data In, and Data Out pads. I used 30 AWG wire for this. 

    Carefully bend the wires so that they are both perpendicular to the PCB and off to one side. Then slide the wires all the way down the shaft and out through the base of the button. 

    Push the wires and PCB all the way back until the PCB is inserted into the circular recess in the button shaft.

    Slide the locking tab into the slot at the top to hold the shaft in place. This tab will also be used when it is time to panel mount the button.

    I attached the LED's wires to a header for ease of use with this small gage wire.

    At this point since everything is still accessible, I would test the push button. When it has checked out you can glue the letter piece to the top of the shaft.

    One down ten to go.

    Testing the Push Button

    I attached the microswitch and the NeoPixel to an Arduino Nano for testing.  Here is the wiring list.

    • NeoPixel 5v to Arduino 5V
    • NeoPixel GND to Arduino GND
    • NeoPixed Data In to Arduino D6
    • Microswitch Common to Arduino GND
    • Microswitch NO to Arduino D5

    And I ran the following sketch:

    #include "FastLED.h"
    
    #define NUM_LEDS 1
    #define LEDS_PIN 6
    #define SWITCH_PIN 5
    CRGB leds[NUM_LEDS];
    
    int buttonPosition = 0;
    boolean buttonDown = false;
    int color = 0;
    
    void setup() {
      Serial.begin(115200);
      Serial.println("Single LED");
      pinMode(SWITCH_PIN, INPUT_PULLUP);
      
      FastLED.addLeds<NEOPIXEL, LEDS_PIN>(leds, NUM_LEDS);
      leds[0] = CRGB::Black; 
      FastLED.show();
    }
    
    void...
    Read more »

  • I Think the Answer Is... (Part 1)

    Michael Gardi12/28/2020 at 21:33 0 comments

    For the original Think-a-Tron, I'm assuming that the game play went something like this:

    1. Someone reads the question from a card.
    2. Both players verbally declare what they think is the correct answer (A, B, C, T, or F).
    3. The card is inserted into Think-a-Tron, which is "activated" and reveals the correct answer.
    4. Players with the correct declared answer manually update their score counters.
    5. Repeat.

    Now I'm assuming this because I have not been able to find a copy of the Instruction sheet that shipped in the box. If anyone out there has this sheet I would be eternally grateful for a copy.

    At any rate Think-a-Tron 2020 will work a little differently:

    1. Someone reads the question from a card.
    2. Both players lock their answers into Think-a-Tron 2020.
    3. The card is inserted into Think-a-Tron 2020, which is "activated" and reveals the correct answer.
    4. Think-a-Tron 2020 automatically increments the score for those players with the correct answer.
    5. Repeat.

    This log addresses how the players would "lock their answers into Think-a-Tron 2020".

    My first thought was to use a rotary switch. I like that rotary switches are a fairly compact way to implement a five choose one input.  I've had a little experience making a rotary switch (Mostly 3D Printed Rotary Switch), but that particular design was special purpose and too big to use here.  I was surprised at how expensive SP5T rotary switches are. The PCB mount ones are pretty cheap but too small and unsuitable. Panel mount switches were $25+ on Digi-Key. (If I were a patient fellow I probably could have sourced some overseas much cheaper.)  

    I could have used a cheap potentiometer in conjunction with an analog input to do the job, but I really wanted to snap the answer in place with proper "detents". 

    So at the end of day I decided to try a DIY approach, and after a couple of days work this is what I came up with. 

    Mostly 3D Printed Rotary Switch Version 2

    It's not a compact as "store bought" at 50 mm in diameter, but it's certainly useable in many situations including mine.  Like a potentiometer, you can read the five different stops with a single analog pin (which was a requirement for my Think-a-Tron 2020 build as I only a few  pins available). As can be seen above, it is panel mount. 

    Here is everything needed to build one.

    In addition to the printed parts you will need:

    • 6 resistors less than 2K in value. Not too important. Mine were 230R.
    • Some small disk magnets 3 mm in diameter and 1.7 mm deep.
    • A short 7 mm length of 2 mm diameter (12 AWG) uninsulated copper wire.
    • Some hookup wire. Mine had soft silicon insulation.

    Here is how to put it together.

    Step 1 - Prepare the Base

    Insert 6 of the magnets into the Base piece. Use a small dab of glue to hold them in place. Make sure that the polarity is the same for all 6 magnets.

    Solder the resistors in series as in the above photo. Each should be 15 mm apart.

    I made a small jig to hold them in place for soldering.

    Insert the resistors into the Base channel, behind the "posts" holding the magnets. The resistors go directly behind the posts while the soldered leads go into the "gaps".

    When you are satisfied that all the resistors are positioned correctly, push them down to the bottom of the channel, then secure them in place with the "Gasket" piece.

    Step 2 - Prepare the Rotor

    Insert a magnet into each of the three holes on side of the rotor.  NOTE: The magnets should be oriented so they attract the magnets that have been set into the inside of the Base. 

    Insert a stack of three magnets into the hole at the back of the trough pictured above.

    Use a little glue to hold all of the magnets in place.

    Glue the Rotor Top onto the Rotor so that the trough becomes a small square tunnel. I've aligned the flat edge of the shaft with the left edge of the trough.

    Step 3 - Prepare the Piston

    Insert a stack of four magnets into the hole at...

    Read more »

  • And the Answer Is...

    Michael Gardi12/23/2020 at 15:52 0 comments

    The Hardware

    I did a fair amount of research before I decided to use QR codes to encode my answers. I discovered that there was a lot of activity around using the ESP32-CAM module to read QR codes. 

    The ESP32-CAM is a very small camera module that combines an ESP32-S chip with an OV2640 camera that sells for about $10.

    Since I needed an MCU for this project anyway this seemed like a good fit. Once the ESP32-CAM is programmed, and assuming that the built-in microSD slot is not used, there are 10 I/O pins available for general use. Notice that there is no USB port. Programing the ESP32-CAM requires an FTDI programmer.

    I bought a "bundle" that included the ESP32-CAM with OV2640 camera installed, an FTDI programmer, and a 40 pin bundle of female/female jumper wires for about $15 US off of Amazon. 

    I won't go into details here, but you can click this link for a great tutorial on setting up the ESP32-CAM.  I followed these instructions and got the Video Streaming Server working easily. Pretty cool stuff.

    The Software

    If you google "ESP32-CAM QR code reader" you will get a lot of results. Having looked at a few of the videos and read a number of the tutorials returned by that search, I realized that the big difference between what has been done so far, and what I am trying to do, is that the QR codes being scanned in these posts were all fairly large.  I am trying read a 1 1/2 inch square QR code from the back of a business card.  So I setup a little test rig to see if it could be done (spoiler alert: it can).

    The trivia card is inserted into a holder that can slide towards and away from the stationary camera. The ESP32-CAM is connected to the FTDI programmer. I ran the Video Streaming Server example mentioned in the installation tutorial. 

    I used this setup to determine the optimal distance between card and camera by sliding the card into a position so that the QR code occupies most (say 90%) of the frame.  This turned out to be about 65 mm for me.  With the card positioned, focus the camera to get the sharpest image possible buy carefully twisting the lens.  To this end I designed a small tool to securely hold the camera in place while the lens was being turned. 

    You have to apply a fair amount of torque to adjust the lens.

    Once the camera was calibrated it was time to try reading the QR code.  It tried a couple of different tutorials, but found that the one linked here worked best for me. The only changes I made to the test code from that tutorial were to translate the Portuguese comments to English, and to enable the ESP32-CAM's on board flash when reading the QR code.

    //Bibliotecas utilizadas
    #include "ESPino32CAM.h"
    #include "ESPino32CAM_QRCode.h"
     
    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
    #define flash 4
     
    void setup() {
       
      Serial.begin(115200);
      Serial.println("QR Code Reader");
      // Define the flash pin.
      pinMode(flash,OUTPUT);
      digitalWrite(flash, LOW); // Turn off the flash.
         
      // Configure the camera pins.
      camera_config_t config;
      config.ledc_channel = LEDC_CHANNEL_0;
      config.ledc_timer = LEDC_TIMER_0;
      config.pin_d0 = Y2_GPIO_NUM;
      config.pin_d1 = Y3_GPIO_NUM;
      config.pin_d2 = Y4_GPIO_NUM;
      config.pin_d3 = Y5_GPIO_NUM;
      config.pin_d4 = Y6_GPIO_NUM;
      config.pin_d5 = Y7_GPIO_NUM;
      config.pin_d6 = Y8_GPIO_NUM;
      config.pin_d7 = Y9_GPIO_NUM;
      config.pin_xclk = XCLK_GPIO_NUM;
      config.pin_pclk = PCLK_GPIO_NUM;
      config.pin_vsync = VSYNC_GPIO_NUM;
     config.pin_href =...
    Read more »

  • Trivia Card Pursuit

    Michael Gardi12/22/2020 at 22:12 0 comments

    Trivia cards for the original Think-a-Tron were pretty small at just 1 1/4 x 2 1/2 inches.

    As has been mentioned, the punched holes and corner cut were just for show, only the notch on the right mattered. I wonder how long it took the kids "playing" Think-a-Tron to figure this out? The cards were also two sided.  150 cards (300 questions) shipped in the box. Additional sets of 50 cards (100 questions) on specific topics like sports could be purchased separately.

    I had to decide what kind of cards to use for Think-a-Tron 2020.  Some criteria:

    • The answer had to be part of the question card and should not be too easy to figure out, like the "notch" was. 
    • I needed to be able to somehow "read" the answer from the card. 
    • The trivia cards should be easy for anyone to create.  

    After considering this for a while, I settled on the following:

    • Think-a-Tron 2020 trivia cards will use a standard business card format of 3 1/2 x 2 inches. I chose this size because blank card stock and word processing templates are readily available. The larger size will also allow for more easily readable questions (old eyes).
    • Questions will appear on the front of the card, and answers on the back, so only a single question per card.
    • Answers will be encoded as QR codes. I considered bar codes but I think that QR codes are cooler looking.

    So I purchased some blank business card stock (Avery 5371) and using MS Word with the Avery template created some test cards.  Seen here are the front of the printed sheet on the left and back on the right.

    The QR codes were created online at the QR Code Generator site. I created one QR code image for each of the possible answers (A, B, C, T, F).  It should be noted that it is still possible at this point to figure out the correct answer by looking carefully at the QR code. This is because the "payload" for each is just a single letter. My plan is to write an application to automate the creation of these cards at which time I will obfuscate the payload by adding some random "noise" to each answer.

    So I ripped along the dotted lines and viola I have a small test deck of trivia cards to work with.

    Next up, reading the QR codes.

  • Let There Be Lights

    Michael Gardi12/22/2020 at 16:21 0 comments

    So I set about making the "Answer Panel" for my Think-a-Tron 2020.  Here is what the original looks like.

    I was so impressed with the spinning wheel implementation of the original, that for a while I considered doing something similar, but motor driven perhaps.  At the end of the day though I decided to replace what I initially thought was an LED array with an actual 5x7 LED array.

    The panel on the original 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 these:

    NeoPixel compatible, WS2812B addressable, smart RGB LED pixel lights. They are individual units but ship attached in a 10x10 grid as can be seen in the picture 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. The  pixel lights shipped with a three wire connector that I attached.

    The next order of business was to make a diffuser for the lights.  This is what I came up with.

    It's all one piece. I printed the black backing panel, paused the print, then finished with some "transparent" PLA filament. Not quite as clear as the original, but it gets the job done.

    I printed a case. 

    And when it was all put together here is what it looked like.

    For testing purposes I connected the display to an Arduino Nano and wrote a short sketch using the 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);
      }
    }

     And here is my "real" 5x7 Answer Panel in action.

  • How the Original Think-a-Tron Works

    Michael Gardi12/19/2020 at 21:22 0 comments

    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.

    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. 

    With the back cover removed you can see the first big reveal. 

    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 into the release position in the photo above.

    Finally...

    Read more »