Story
For years, we made our boards “talk” by playing MP3 clips. Great for demos — until you need new words or real-time values. A handful of fixed phrases, big flash footprints, and no flexibility meant every change required reflashing.
We asked a different question: could a microcontroller generate voice on the fly? Cloud TTS proved the idea years ago; we wanted the same freedom on the edge, on hardware that runs from a small battery.
So we paired the CrowPanel Advance for the interface with our GRC TinyTTS Kit built on the Himax HX6538 (Cortex-M55 + Ethos-U55) for synthesis. The difference was instant: no more playback — the device was speaking.
- The user types text on a PC.
- The text is sent over USB to the CrowPanel (ESP32-S3).
- CrowPanel forwards the text via UART to the TinyTTS kit.
- The HX6538 synthesizes speech in real time.
- Audio is played through the module’s 3.5 mm jack to external speakers or headphones.
And yes — you can input any text you want. Even several paragraphs will be spoken aloud.
Why It’s Cool
It feels different when the board isn’t just faking voice but creating it:
- Any phrase, not just a library.
- Numbers, dates, sensor values generated on demand.
- Dynamic warnings with exact details.
- Flash left clean — no pile of audio files.
- Works offline — no cloud, no latency.
It’s the difference between pressing play and having a conversation.
Where It Fits
We think TinyTTS could be useful for things like:
- sensors that read out live values,
- devices that speak their own errors,
- robots narrating their actions,
- toys or learning kits with flexible dialogue,
- safety systems that voice the right alert at the right time.
But honestly — that’s just our guesswork. The real wow might come from places we haven’t even imagined.
Known Limits
- Best for short to medium text; very long paragraphs are possible, but not the primary target.
- Voice quality tuned for MCU memory, not hi-fi.
- Limited voices/languages out of the box (only English now).
- External speakers required (via 3.5 mm jack).
Hardware Required
- CrowPanel Advance
- GRC TinyTTS kit (Himax HX6538, Cortex-M55 + Ethos-U55)
- USB-C cable (for flashing CrowPanel)
- UART jumper wires (TX/RX + GND)
- Active speakers or headphones (3.5 mm jack)
Wiring
- CrowPanel TX → TinyTTS RX
- CrowPanel RX → TinyTTS TX
- GND → GND
- Audio out: 3.5 mm jack on TinyTTS → speakers
- Power: via USB-C (CrowPanel) and 5 V (TinyTTS)
Set the UART1-OUT switch on CrowPanel to WM mode (see photo).
Firmware & Software
- Flash CrowPanel with the provided Arduino sketch (LVGL text input + UART output).
- GRC TinyTTS kit comes pre-flashed with firmware for on-device synthesis.
- Source code and examples available on GitHub.
Running the Demo
- Connect CrowPanel to your PC via USB-C and upload the demo sketch.
- Wire CrowPanel ↔ GRC TinyTTS over UART.
- Plug speakers into the 3.5 mm audio jack on the TinyTTS.
- Power up CrowPanel
- Run an app from python/app, enter text on the PC, send it to the CrowPanel, and press "Say" on the CrowPanel touchscreen.
- The TinyTTS module will synthesize and play the spoken audio.
What’s Next
This setup isn’t just a demo — it’s a playground for testing new ideas.With GRC TinyTTS kit you can quickly prototype voice features and see how they feel in real hardware.Once a prototype works the way you want, you can take the GRC TinyTTS kit and drop it into another environment — an Arduino project, or even directly into a working device.That way, the same tech can move smoothly from experiment to production.
Wrap-Up
It’s a strange and joyful feeling when a bare board suddenly starts to talk.It reminded me of when I built my first radio receiver, switched it on — and it SPOKE.
Even more exciting is figuring out where this voice will truly matter.And this is only the beginning — the next chapter will be written by you, deciding what should speak.
