Group Actions
Engagement
  • Author Author: Grovety
  • Date Created: Date Created
  • Views 49 views
  • Likes 1 like
  • Comments 0 comments
Related
Recommended

A Simple Talking Quiz Using an MCU

Grovety
A Simple Talking Quiz Using an MCU

This is a small interactive quiz that uses a touch UI, simple graphics, and an offline speech module to create a playful way to learn about animals.

When the user taps the screen, the device shows a short question, speaks it offline, and then displays the correct animal along with an optional explanation. The goal was to make a light, self-contained form of electronic entertainment that reacts immediately, without cloud services or complex software stacks.

The project runs on a compact MCU-based system with a capacitive touch screen and a tiny speech synthesizer module.
Each quiz item consists of an image, a short text line, and a spoken phrase.
The device displays an animal, waits for a tap, and then plays the corresponding spoken hint.
Because everything is generated on the microcontroller, the reaction feels fast and natural.

The same template can be reused for other simple games: geography quizzes, vocabulary trainers, museum exhibits, or STEM activities for kids.
In this version, the focus is on animals — a straightforward theme that makes the game easy to test and fun to demonstrate.

Components / Materials Used

  • Elecrow CrowPanel (5–7 inch touch display) – the main touchscreen interface that runs the quiz UI and sends commands when the user taps an animal

  • Grovety TinyTTS Kit – an offline speech module that generates spoken phrases directly on its internal microcontroller.

  • Small speaker – connected to the TinyTTS audio output for playback

  • UART cable / connection wires – to connect CrowPanel to the TinyTTS module

  • 5V USB power source – used to power the system

System Overview / How It Works

The system consists of two main parts:

  1. a touchscreen interface running on the Elecrow CrowPanel, and

  2. a TinyTTS module that generates speech offline.

image

The CrowPanel displays a simple grid of animal images. Each image corresponds to a short description line stored in the project assets. When the user taps an animal, the CrowPanel sends a small UART message to the TinyTTS module. The message contains the ID of the selected animal, which determines what phrase should be spoken.

The TinyTTS module receives the command and immediately synthesizes the corresponding audio line on-device. The output is sent directly to a small speaker. Because everything runs locally on microcontrollers and does not rely on cloud services, the reaction feels instant: touch → message → speech.

This architecture makes the system easy to extend. New quiz items require only an additional image and a short text string. The speech module handles all audio generation internally, without external audio files or pre-recorded samples.

Running the Firmware

You can use the project in two ways:

Option A — Run the ready-made firmware (no coding required)

This is the fastest way to try the quiz.

  1. Download the prebuilt firmware bundle from the project repository (from the firmware/ folder).

  2. Run the included Flash Tool — it flashes all required images with the correct layout.

Option B — Build from source

This option is for modifying the UI, quiz logic, or integrating new content.

  1. Open the project directory in ESP-IDF.

  2. Build and flash:

    idf.py build
idf.py -p PORT flash
This compiles the LVGL UI, the quiz logic, and generates the required SPIFFS image.

Hardware Assembly

Connect the CrowPanel to the TinyTTS module over UART (TX-RX and GND), attach a small speaker to the TinyTTS audio output, and power the CrowPanel from a 5V USB source.

image

Customization – Editing Text and Images

You can fully customize the quiz to create your own theme. The UI, text strings, and images are defined in separate files, so you can introduce new items or replace the existing content with minimal changes. This allows the same structure to be reused for topic-based quizzes, simple vocabulary trainers, object catalogs, museum or exhibit touch displays, or small workshop demos that show how a touchscreen interface and an offline speech module communicate over UART.

1. Add or change objects in the text

  • Add new case IDs in components/ui/include/builtin_texts.h.

  • Write the spoken riddle text for each case in components/ui/builtin_texts.c.

  • Add the on-screen question and answer options for each case in components/ui/ui_events.c.

2. Connect each object to its image

  • Convert your PNG/JPG to an LVGL RAW .bin and place it into assets/.

  • Add the matching ui_img_*.c wrapper to components/ui/.

  • Map your case ID to this image in kVisuals[] in components/ui/ui_events.c.

For exact file names, code snippets, and conversion steps, refer to the detailed guide in readme_edit_scenario.md.

Source Code

The complete project is available on GitHub:
https://github.com/Grovety/Crowpanel_ImgTTS_animals

Repository Structure

  • firmware/ – Flash Tool and prebuilt binaries (application, bootloader, partitions, SPIFFS image).

  • main/ – ESP-IDF application code: UART communication with TinyTTS, asset loading, system setup, and integration logic.

  • components/ui/ – SquareLine Studio project and all UI-related code: LVGL screens, widgets, and the quiz flow (questions, answers, navigation).

  • assets/ – RAW image frames that are packed into the SPIFFS partition and shown during the quiz.

  • images/ – Images used in the project README; not part of the quiz UI.

  • readme_edit_scenario.md – Notes on how to modify the quiz content and structure.

Thanks for reading. This was a small experiment, and I hope it’s useful for anyone exploring simple ways to add offline speech to embedded interfaces. If you have suggestions or ideas for extending the project, feel free to comment.