Guessatron

Greetings, everyone!

Meet Guessatron—a pocket-sized marvel that plays 20 Questions and tries to guess what you're thinking. Just think of anything—a mango, a microscope, maybe even Mars—and Guessatron will interrogate your imagination one question at a time, narrowing down possibilities until it locks onto your answer.

Guessatron is like the OG Akinator; you think of something and this device will guess that thing!

This tiny device fits comfortably in the palm of your hand. Housed in a custom-designed, 3D-printed enclosure, it’s powered by a 3.7V 2000mAh LiPo cell, making it fully portable and self-sufficient.

Inside, it runs a smart logic tree capable of guessing up to 70 different objects—and the best part? You can expand its database to include even more.

This Instructables is about the complete build guide of this project, so let's get started with the project.

These were the materials used in this project:

1. Waveshare ESP32-S3-LCD-1.69 Screen (provided by PCBWAY)
2. LiPo Cell 3.7V 2000mAh
3. Slide Switch
4. Push Buttons
5. Perf Board
6. Connecting Wires
7. 3D Printed Parts

Guessatron is based on the well-known online guessing game Akinator, which amazes players by using AI and huge datasets to guess what they are thinking. However, I wanted to create something that seemed solid, grounded, and local rather than depending on machine learning or cloud-based intelligence. A guessing game that only uses embedded logic and doesn't use the internet or artificial intelligence.

Guessatron makes no claim of being intelligent, in contrast to Akinator. It isn't real-time adaptation or learning from millions of players. It does, however, provide a delightful, standalone experience: an ESP32-powered guessing game that selects your object from a carefully selected library of 70 objects (and counting) and poses yes/no questions.

This project is also a technical playground—combining a custom 3D-printed enclosure, onboard power via a 3.7V 2000mAh LiPo cell, and a crisp display interface. It’s designed to be held, played with, and expanded. Guessatron may not be as smart as Akinator, but it’s something you can build, hold, and proudly show off.

We began the project's design or development process by first importing the screen into Fusion360, along with the models for the slide switch, lithium battery, and switchboard with three push buttons.

The objective was to design a very portable and robust device that anyone could hold in their hand. It will include three buttons that users can press to operate the device.

Following the guidelines, we positioned the switchboard below the display with a slight leftward shift and the display in the center. The sliding switch was positioned on the right side of the model, aligned with the switchboard, and the lithium battery was positioned on the opposite side of the display.

Now comes the design part; We created a shape that resembles a cuboid with rounded corners, drawing inspiration from an old television. The ESP32 display was raised just above the switchboard's level, and we created a box-like part around it that creates an illusion that the screen is positioned slightly outside. This created an intriguing design element and enhanced the device's visual appeal.

Similarly, we modeled the buttons that are positioned above the enclosure boundary for switch actuators.

The Entire device is split into two parts: the front and back enclosures, shelling out both bodies, creating ribs that line up with the display and switchboard, and even creating a holding part for the slide switch.

The front and rear enclosures were joined together by three holes on each body; we essentially assembled them and fastened them together with three M2 screws. Since we didn't have much room for screw bosses, we decided to use hot glue to secure the remaining components in place.

By the way, if you're diving into plastic part design, I strongly recommend checking out design guides from companies like DuPont, 3M, and GE Plastics. These resources offer deep insights into the entire engineering process—from proper part construction to critical factors like shrinkage, tooling, and material behavior. Studying these guides can significantly simplify the design workflow and help you avoid common pitfalls.

We exported the mesh files for every component after finishing the design; the front enclosure was printed in transparent PLA. The back enclosure and switch actuators were printed using our Creality K10 Max with orange PLA.

The ESP32-S3-LCD-1.69 is the real star of this setup. Despite its small size, it is incredibly powerful. Its dual-core Xtensa LX7 processor, which can run at up to 240 MHz, provides seamless performance for everything from input handling to display rendering. With its integrated Wi-Fi and Bluetooth 5, it can connect without the need for additional modules or complicated wiring.

Memory-wise, it’s stacked: 512KB of SRAM, 384KB of ROM, plus 8MB of onboard PSRAM and 16MB of external Flash.

This board is loaded with features that enhance our Guessatron, including a 1.69-inch capacitive LCD screen, a lithium battery charging chip, and a six-axis sensor with a three-axis accelerometer and gyroscope.

It has an ETA6098 lithium battery charging chip for long-term power management, a QMI8658 inertial measurement unit (IMU) for motion tracking, and an RTC chip for clock functions.

Audio feedback can be provided by the integrated buzzer; demo flashing is made simple by the Type-C interface. Furthermore, the BOOT and RST buttons make firmware downloads and resets easier, and a function button that may be customized allows for single, double, and long pushes, among other input ways.

Although the ST7789V2 LCD controller's active display area is 240(H) × RGB × 280(V), it offers a 240 × RGB × 320 resolution. It is compatible with RGB444, RGB565, and RGB666 color formats; for best visual results, our project uses RGB565.

The display's smooth corners add to its elegant, small appearance, and the four-wire SPI interface guarantees effective GPIO usage and quick communication speed.

You can check out more about this display from its Wiki page: https://www.waveshare.com/wiki/ESP32-S3-LCD-1.69

As for sourcing the ESP32-S3-LCD-1.69 we use in our project, we got it from PCBWAY's Giftshop.

https://pcbway.com/s/cr77wO

PCBWAY gift shop is an online marketplace where you can get a variety of electronics modules and boards for their genuine price, or you could use the PCBWAY currency, which is called beans.

You get beans after ordering something from PCBWAY as reward points, or you can also get them by posting any project in the PCBWAY community.

Over the past ten years, PCBWay has distinguished themselves by providing outstanding PCB manufacturing and assembly services, becoming a trusted partner for countless engineers and designers worldwide.

You guys can check out PCBWAY if you want great PCB service at an affordable rate.

1. A custom three-button PCB made on a Perf board will be used for the inputs. The GPIO Pins of the ESP32 S3 Board will be linked to this Perfboard button PCB.
2. First, we link all three push button pins 3 together; this common connection will be connected to GND.
3. By connecting the NO button to GPIO13, the YES button to GPIO12, and the SOMETIMES button to GPIO14, we link the Button PCB to the ESP32 S3 board's GPIO Pins.

1. Connecting the LiPo cell's positive to the ESP32 S3 board's battery connector's positive pin starts the power source wiring process.
2. The LiPo cell's GND is linked to the COM terminal of a slide switch, and the NC terminal is then connected to the GND pin of the battery connector. We can turn the device on or off with this slide switch.

We now start the enclosure assembly process by installing the slide switch into its designated location within the front enclosure part.

1. Making sure the USB type C is facing the top, we now place the ESP32 S3 Board in its proper location.
2. The slide switch and the display are then secured in place by applying hot glue using a hot glue gun, first over the slide switch and then over the display.

1. The three 3D-printed switch actuators are now positioned in the proper mounting holes on the front end.
2. Making sure the actuators touch the push button, we now place the Switch PCB above the Switch actuators.
3. The Switch PCB is mounted in place using hot glue.

1. We Place the Lipo cell inside the front enclosure for the final assembly and then add the back enclosure from the back side.
2. We now secure the front and back enclosures together with three M2 screws by screwing them into the three mounting holes that were added to the top and bottom faces of the enclosure.

Now that our device has been assembled, let's go to the most critical stage of the project: the coding stage.

Here's the code we have developed for this project, and it's not exactly simple, but with a solid logic table ready and help from my new friend, Mr. AI, i was able to complete this project.

Display & Input Setup

We first added the two important libraries required to run our SSD1306 OLED screen. SCREEN HEIGHT, SCREEN WIDTH and OLED RESET have been added, which define the display.

These define the GPIO pins for the three buttons.

object70.h

We have added a custom header file that stores a list of 70 objects, each with a name and a set of expected answers to the 40 questions in our logic tree.

This file is the backbone of the guessing game. It defines a list of 70 objects, each with a name: "Dog," "Cat," "Mouse," etc. Each object’s answer array acts like a fingerprint; it tells the system how that object would respond to each question.

Question Tree Structure

Each node represents a question and depending on the user’s answer (yes/no/sometimes), the game navigates to a different next question.

the index maps the question to a position in the answers[] array.

Object Database

This section Loads 70 predefined objects from a separate file. here, each object has a unique answer pattern.

Question Tree

This is the full decision tree with 40 questions. Each question leads to another based on YES/NO/SOMETIMES.

Game State Variables

Displaying Questions

This section clears the screen and shows the current question on display.

Reading Button Input

This part waits for a button press and debounces it, then returns the corresponding answer value.

Guessing the Object

This Section compares user answers to each object’s expected answers, then picks the object with the highest match score.

Setup Function

This part Initializes the display and buttons and then resets the game state.

Main Game Loop

The Main Section displays a question, reads input, and stores the answer.

It Navigates the tree or picks the next unasked question and after 20 questions, it guesses the object.

I created this logic table for my guessing game, and once you get the feel of it, it's actually rather simple. With 40 questions that each function as a node, I created it as a decision tree. There are three alternative answers to each question: YES, NO, and SOMETIMES.

It all starts with the first question: “Is it alive?” If the user says YES, the game jumps to question 2: "Is it an animal?" Another YES takes us to question 5: "Does it live with humans?" And so on.

Until the system generates its best estimate, the options are reduced with each response, which leads the path further into the tree.

Some questions lead directly to an object; those are marked as END in the table, meaning they don’t branch further. But if the user gives answers that don’t follow any valid path in the tree, the system won’t find a match. That’s intentional.

Additionally, certain questions are skipped completely—they are never displayed and the user's answers remain blank—depending on how they answer them early on.

In summary, only relevant questions influence the final guess, and the tree dynamically adjusts to the user's selections.

During early testing, Guessatron was able to correctly identify things like "dog" and "laptop," demonstrating that its question flow and logic tree are operating as planned. The device asks a succession of yes/no questions, and after a few simple steps, it latches onto the right response, making the experience feel remarkably intuitive. It feels like a little magic trick to watch it make the correct prediction, especially since the entire deduction takes place offline on a little embedded device.

The current database includes 70 distinct objects, and the branching logic is designed to guide the user through a streamlined decision path. Each guess feels earned, and the interaction is smooth when the user follows the expected question flow.

Nevertheless, Guessatron isn't flawless just yet. Halting behavior when users deviate from the preset logic tree is one known problem. A response that deviates from the anticipated course could cause the device to halt or fail to come to a conclusion.

This is a natural limitation of static decision trees, and we're already working on refining the code to make it more resilient and adaptive in future revisions.

For now this project has been completed and i will be revisiting this project with a new revision real soon.

In addition, we appreciate PCBWAY's support of this project. Visit them for a variety of PCB-related services, such as stencil and PCB assembly services, as well as 3D printing services

Thanks for reaching this far, and I will be back with a new project pretty soon.

Peace.