From A Silent Tool To A Talking Instrument

Most MCU-based devices are silent — yet that silence hides a huge opportunity.

Picture this: you’re holding two probes on a busy board, adjusting a supply or watching how a circuit responds. Each time you take a measurement, you briefly look away at the LCD, then back to the test point. It’s a small interruption — but it happens constantly, and it breaks the flow of working with the circuit.

Now imagine the same workflow, but the multimeter simply tells you the value.

You measure… and you hear the value.

Your hands stay steady; your attention stays exactly where it needs to be.

This project shows how easily a microcontroller can gain a voice — and how spoken measurements make tools far more convenient and intuitive to use.

Here, you’ll build a complete solution that turns a digital multimeter into a talking instrument using an Arduino-class board and TinyTTS.

It’s both a practical tool and a template for adding voice to any measurement device.

A voice-enabled multimeter that:

• reads measurement packets from a standard digital multimeter,
• parses mode and value on an Arduino-compatible board,
• and speaks the results aloud through TinyTTS, fully offline.

It will automatically:

• announce voltage, current, resistance, capacitance, frequency, etc.,
• convert numbers into natural speech (“three point eight six volts”),
• warn on overload or disconnection,
• and start up with “System ready.”

All with just three components:

a multimeter, an Arduino-class board, and a TinyTTS module.

This build needs only three components:

1. TinyTTS module

Generates all speech offline and handles voice output.

2. Arduino-class board (ATmega328P compatible)

UNO, Nano, or Lotus — any 328P-based board works.

3. Digital multimeter with UART packet output

Any model that sends 19-byte measurement frames.

Optional: small speaker or headphones, USB cable for flashing.

Connect the hardware

• Multimeter → Arduino (TX/RX)
• Arduino → TinyTTS (TX/RX)
• Plug Arduino into your PC

Two ways to get your multimeter talking — choose the one you prefer.

You only need to flash your Arduino — TinyTTS requires no firmware flashing and speaks any text sent to it out of the box.

1. Run VoiceMultimeter_Tool.exe

• Select your Arduino board
• Click Flash Now

2. Power the multimeter

You should hear “System ready.”

Start measuring — values will be spoken automatically.

________________________________________

1. Install Arduino IDE 1.8.x or later

2. Clone the repository

3. Open main/main.ino

4. Select board: Arduino UNO / Nano / Lotus

5. Select the correct COM port

6. Upload the sketch (Ctrl+U)

That’s all — TinyTTS will immediately begin announcing modes and measurement values.

At its core, the system does one simple thing:

take measurement data from a multimeter → turn it into text → let TinyTTS speak it.

Here’s how the pieces work together:

The multimeter sends 19-byte UART packets containing:

• measurement mode (DCV, ACmA, Ω, Hz, etc.)
• numeric value
• unit
• overload and status flags

The firmware includes three small modules:

• SerialBridge — receives raw packets and tracks connection state
• MultimeterParser — extracts mode, value, unit, overload
• Main Logic — converts these into spoken phrases (“three point eight six volts”, “resistance”, “overload”, etc.)

Timing rules prevent spam:

• mode changes are spoken immediately
• measurement values are spoken at safe intervals

Arduino sends plain text over UART:

"three point eight six volts"
"resistance"
"overload"

TinyTTS speaks the phrase instantly, offline — no cloud, no network.

The firmware is intentionally modular so each part can be reused in other projects. Everything runs on a simple ATmega328P-based Arduino.

The multimeter sends fixed-length 19-byte frames over UART.SerialBridge handles:

• receiving and buffering packets
• detecting connection, disconnection, and power-off
• exposing a clean “packet ready” interface to the rest of the firmware

This keeps hardware-specific details isolated.

Each frame contains:

• measurement mode (e.g., DCV, ACmA, OHM, CAP)
• numeric display (with decimal point locations)
• unit (V, A, Ω, Hz…)
• overload flag

MultimeterParser converts the raw bytes into a structured Measurementobject used by the main logic.

Two helper functions handle the language layer:

getModeVoiceText()Converts mode codes into phrases like“D C Voltage”, “Resistance”, “Frequency”

formatNumberForSpeech()Converts strings like "3.86" into“three point eight six”

Units are also mapped to spoken forms ("mA" → “m a”, "kΩ" → “k ohm”, etc.).

To avoid flooding the user with constant messages, the firmware uses simple rules:

• mode changes→ spoken immediately
• measurement values → spoken at fixed intervals
• overload→ spoken once per event
• connection/power events → “Connected”, “Disconnected”, “Power Off”

This creates a calm, predictable voice interaction.

TinyTTS is controlled via a single UART:

g_hx_tts->say("three point eight six volts");

No preprocessing, no phonemes, no model loading.TinyTTS simply speaks whatever text is sent, fully offline.

All timing and behavior parameters are in Config.h, including:

VOICE_INTERVAL — how often values are spoken

MODE_CHANGE_DEBOUNCE — stabilize mode transitions

STATE_CHANGE_DEBOUNCE — avoid noisy connection flicker

Most users don’t need to change anything, but advanced makers can fine-tune the experience.

Although this build uses a digital multimeter as the data source, the architecture is completely general.Any device that can send measurement data over UART can become a voice-enabled instrument.

You can reuse the overall pattern in your own projects:a microcontroller reads a value → prepares a short text phrase → sends it to TinyTTS for immediate offline speech.

This makes it simple to add voice feedback to sensor nodes, handheld tools, test fixtures, or accessibility-focused builds.

The project doubles as a minimal reference design for adding voice to measurement equipment:

Sensor module → Microcontroller → TinyTTS → Audio

To turn any test or monitoring device into a talking version, you only need:

• one UART to send text
• a TinyTTS module for speech output

No cloud, no DSP stack, no model integration — the voice layer becomes a plug-in building block.

Source code, firmware, flashing tool, and documentation:https://github.com/Grovety/Voice_Multimeter

Official kits and modules for offline speech generation:

• https://www.elecrow.com/grc-tinytts-kit.html
• https://www.tindie.com/products/40292/

We’d love to see what you create based on this project — whether it’s another talking instrument, a lab tool with voice feedback, or something entirely unexpected.Share your builds and ideas in the comments.

And tell us:Which other tools or devices would benefit the most from having a voice?