Build a Voice Assistant on Arduino with Custom Voice Commands

🚀 On-device Voice AI & LLMs

Build commercial, non-commercial, research projects using the Forever-Free Plan.

TLDR: Build a fully offline Arduino voice assistant with custom wake words and natural language voice commands. This tutorial demonstrates how to run an end-to-end, on-device voice pipeline on a microcontroller using Picovoice's intent-based voice assistant architecture.

Adding Voice Control to Arduino

Embedding voice assistants in microcontrollers is fundamentally different from building voice assistants for web or phone applications. Boards like the Arduino Nano 33 BLE Sense run without an operating system, lack built-in Wi-Fi, and must process audio in real time within strict CPU and memory limits.

In this tutorial, we'll build an offline voice assistant for Arduino, with wake word detection and intent recognition running on the microcontroller within its CPU and memory constraints. The Arduino listens for a custom wake word using Porcupine Wake Word, then processes custom voice commands with Rhino Speech-to-Intent.

This natural language understanding pipeline directly maps user intent from voice commands without an intermediate transcription step, allowing the engine to achieve a benchmarked command acceptance rate exceeding 97% and outperform major big-tech alternatives.

What You'll Build

Based on Picovoice's pico-cookbook recipe, we will build a voice-controlled timer on Arduino Nano 33 BLE Sense featuring:

Wake Word Detection — Activates when you say "Hey Assistant"
Voice Command Recognition — Recognizes intents like start, stop, check, reset, and set timer with custom durations
LED Visual Feedback — Has different colored feedback for different states
- 🟣 Magenta flash — Wake word detected (listening for command)
- 🟢 Solid green — Timer running
- 🔴 Solid red — Timer paused
- 🔵 Blue blinks 3x — Checking timer
- ⚪ White flash 3x — Timer reset
- 🌈 RGB cycling — Timer complete

Build time: 15-20 minutes

Prerequisites

Hardware

Arduino Nano 33 BLE Sense — Built-in microphone (Available from Arduino Store)
Micro-USB cable — For programming and power (ensure it's a data cable, not charge-only)

Software

Arduino IDE — Download from arduino.cc
Picovoice Console account — Sign up free at console.picovoice.ai

Step 1: Install the Arduino SDK

Open Arduino IDE and install the Picovoice_EN library:

Go to "Tools" → "Manage Libraries"
Search "Picovoice_EN"
Click Install

Step 2: Get Arduino's UUID

Every Arduino Nano 33 BLE Sense has a unique hardware identifier (UUID). You'll need this to train voice models for your specific board. Models trained for one board won't work on others without the correct UUID.

Connect your Arduino and load the UUID extraction sketch:

Go to "File" → "Examples" → "Picovoice_EN" → "GetUUID"
Select board: "Tools" → "Board" → "Arduino Nano 33 BLE"
Select port: "Tools" → "Port" → Select the port connected to the Arduino (e.g., /dev/ttyACM0 for Linux, or COM port on Windows)
Click "Upload"
Copy the displayed UUID (format: 27 0f f3 da f2 a0 d1 c8) from "Tools" → "Serial Monitor"

Step 3: Train Custom Voice Models

Get Your AccessKey

Train a Wake Word Model

Create a custom wake word using Porcupine Wake Word Engine:

Navigate to the Porcupine page in the Picovoice Console.
Click "Train Wake Word" and enter a custom phrase such as "Hey Assistant."
Select platform ("Arm Cortex-M"), board type ("Arduino Nano 33 BLE Sense"), and paste your board UUID.
Click "Train" and download the .zip file containing your wake word model.

Train a Context Model for Custom Voice Commands

Create voice commands using Rhino Speech-to-Intent:

Navigate to Rhino Page in the Picovoice Console.
Click "Create Context" and name it.
Click the "Import YAML" button in the top-right corner of the Console. Paste the YAML provided below to add the intents and expressions for the voice assistant:

context:
  expressions:
    start_timer:
      - (@politeness) [start, begin] (a) (the) timer
      - (@politeness) @turn_on (the) timer
      - timer [start, on]
      - (@politeness) [start, begin] counting
    set_timer:
      - (@politeness) count $direction:direction for $pv.TwoDigitInteger:seconds seconds
      - (@politeness) set (a) (the) timer to count $direction:direction for
        $pv.TwoDigitInteger:seconds seconds
      - (@politeness) [start, begin] (a) $pv.TwoDigitInteger:seconds second
        count $direction:direction
    stop_timer:
      - (@politeness) [stop, pause, cancel, end] (the) timer
      - (@politeness) @turn_off (the) timer
      - timer [stop, off, pause]
      - (@politeness) pause counting
    resume_timer:
      - (@politeness) [resume, continue] (the) timer
    check_timer:
      - (@politeness) [how much, what] time is [left, remaining]
      - what's the time [remaining, left]
    reset_timer:
      - (@politeness) [restart, reset] (the) timer
  slots:
    direction:
      - up
      - down
  macros:
    politeness:
      - please
      - can you
      - could you
    turn_on:
      - turn on
      - switch on
      - set
      - activate
    turn_off:
      - turn off
      - switch off
      - deactivate

Select platform ("Arm Cortex-M"), board type ("Arduino Nano 33 BLE Sense"), and paste your board UUID.
Click "Train" and download the .zip file containing your speech-to-intent model.

The Rhino context defines the vocabulary of voice commands that the voice assistant understands. Each intent maps to natural variations of voice commands that users might say.

Step 4: Open the Arduino Sketch to build the Voice Assistant

Open the Arduino IDE and go to:

"File" → "Examples" → "Picovoice_EN" → "IntentBasedVoiceAssistantExample"

The sketch opens with two tabs:

IntentBasedVoiceAssistantExample.ino — Main logic
pv_params.h — Model parameters (contains default wake word and context)

Step 5: Configure the Sketch with Custom Voice Models

Update pv_params.h

Unzip the downloaded files from Picovoice Console. You'll have:

Wake word package:

.h file containing KEYWORD_ARRAY
.ppn file

Context package:

.h file containing CONTEXT_ARRAY
.rhn file

In the pv_params.h tab, replace:

KEYWORD_ARRAY with the array from your wake word .h file
CONTEXT_ARRAY with the array from your context .h file

Update AccessKey

In the IntentBasedVoiceAssistantExample.ino tab, find this line and replace with your AccessKey from Picovoice Console:

static const char *ACCESS_KEY = "${ACCESS_KEY}";

Step 6: Run & Test Voice Commands on Arduino

Click "Upload" in Arduino IDE and open the "Serial Monitor"
Say "Hey Assistant." You should see a wake word detection message in the Serial Monitor.
After wake word detection, say a voice command e.g., "Start the timer"

The Serial Monitor displays the detected intent and any extracted "slots" or parameters.

Step 7: Add Voice-Controlled Timer & LED Feedback to Arduino

Now let's implement the LED feedback using the Arduino Nano 33 BLE Sense's built-in RGB LED. The timer will support counting up, counting down, pause/resume, and completion alerts.

If you want to skip the breakdown of the code and see the final logic, scroll down to the full code section.

LED Helper Functions for Arduino

Add LED pin definitions and helper functions at the top of your sketch (after the includes):

// LED Pins
#define LED_RED     22
#define LED_GREEN   23
#define LED_BLUE    24

void setLED(bool red, bool green, bool blue) {
    digitalWrite(LED_RED, red ? LOW : HIGH);
    digitalWrite(LED_GREEN, green ? LOW : HIGH);
    digitalWrite(LED_BLUE, blue ? LOW : HIGH);
}

void blinkLED(bool red, bool green, bool blue, int times, int delayMillis) {
    // Blink specified color pattern. See full code for implementation
}

void alertComplete() {
    // RGB cycling alert for timer completion. See full code for implementation
}

Create Timer State Machine

Add timer state variables and core timing functions:

// Timer State
enum TimerMode { TIMER_MODE_COUNTUP, TIMER_MODE_COUNTDOWN };
enum TimerState { TIMER_STOPPED, TIMER_RUNNING, TIMER_PAUSED };

static TimerState timerState = TIMER_STOPPED;
static TimerMode timerMode = TIMER_MODE_COUNTUP;
static unsigned long timerStartMillis = 0;
static unsigned long timerPausedMillis = 0;
static unsigned long targetDurationMillis = 0;
static unsigned long lastDisplayUpdate = 0;
#define TIMER_UPDATE_INTERVAL 1000

unsigned long getElapsedMillis() {
    // Returns elapsed time based on timer state. See full code for implementation
}

unsigned long getRemainingMillis() {
    // Returns remaining time for countdown mode. See full code for implementation
}

void formatTime(unsigned long totalSeconds, char *buffer, size_t bufferSize) {
    // Formats seconds as MM:SS string. See full code for implementation
}

void displayTimerStatus() {
    // Prints current timer status to Serial. See full code for implementation
}

Create Timer Control Functions

Add functions to control the timer:

void startTimer() {
    // Start counting up from zero
}

void startCountdown(int seconds) {
    // Start counting down from specified seconds
}

void startCountup(int seconds) {
    // Start counting up to specified seconds
}

void stopTimer() {
    // Pause the timer, set LED red
}

void resumeTimer() {
    // Resume paused timer, set LED green
}

void checkTimer() {
    // Display status, blink blue 3x
}

void resetTimer() {
    // Reset to zero, flash white
}

void checkTimerComplete() {
    // Check if timer reached target, trigger alert
}

// See full code for implementation

Implement Voice Commands on Arduino

Add a function to map voice intents to timer actions:

void handleTimerIntent(const char *intent, int32_t num_slots, const char **slots, const char **values) {
    if (strcmp(intent, "start_timer") == 0) {
        if (timerState == TIMER_PAUSED) resumeTimer();
        else startTimer();
    }
    else if (strcmp(intent, "set_timer") == 0) {
        // Parse seconds and direction slots
        // Call startCountdown() or startCountup()
    }
    else if (strcmp(intent, "stop_timer") == 0) stopTimer();
    else if (strcmp(intent, "resume_timer") == 0) resumeTimer();
    else if (strcmp(intent, "check_timer") == 0) checkTimer();
    else if (strcmp(intent, "reset_timer") == 0) resetTimer();
}

// See full code for implementation

Modify the Callback Functions

Update wake_word_callback to add LED feedback:

static void wake_word_callback(void) {
    Serial.println("Wake word detected!");
    setLED(true, false, true);  // Magenta flash
    delay(200);
    // Restore LED to current timer state
    if (timerState == TIMER_RUNNING) setLED(false, true, false);
    else if (timerState == TIMER_PAUSED) setLED(true, false, false);
    else setLED(false, false, false);
}

// See full code for implementation

In inference_callback, call the intent handler when a command is understood:

if (is_understood) {
    handleTimerIntent(intent, num_slots, slots, values);
}

Initialize LED & Serial Monitor Updates for Arduino

Initialize LED pins:

pinMode(LED_RED, OUTPUT);
pinMode(LED_GREEN, OUTPUT);
pinMode(LED_BLUE, OUTPUT);
setLED(false, false, false);

Add timer display updates at the end of loop():

// Update timer display periodically
if (timerState == TIMER_RUNNING) {
    unsigned long currentMillis = millis();
    if (currentMillis - lastDisplayUpdate >= TIMER_UPDATE_INTERVAL) {
        lastDisplayUpdate = currentMillis;
        displayTimerStatus();
        checkTimerComplete();
    }
}

Full Code for On-Device Voice Control on Arduino

#include <Rhino_EN.h>
#include <Porcupine_EN.h>
#include "pv_params.h"

#define MEMORY_BUFFER_SIZE (50 * 1024)

static const char *ACCESS_KEY = "${ACCESS_KEY}"; 

pv_porcupine_t *ppn_handle = NULL;
pv_rhino_t *rhn_handle = NULL;

static int8_t ppn_memory_buffer[MEMORY_BUFFER_SIZE] __attribute__((aligned(16)));
static int8_t rhn_memory_buffer[MEMORY_BUFFER_SIZE] __attribute__((aligned(16)));

static const float PORCUPINE_SENSITIVITY = 0.75f;
static const float RHINO_SENSITIVITY = 0.5f;
static const float RHINO_ENDPOINT_DURATION_SEC = 1.0f;
static const bool RHINO_REQUIRE_ENDPOINT = true;

static const int32_t KEYWORD_MODEL_SIZES = sizeof(KEYWORD_ARRAY);
static const void *KEYWORD_MODELS = KEYWORD_ARRAY;

#define LED_RED     22
#define LED_GREEN   23
#define LED_BLUE    24

enum TimerMode { TIMER_MODE_COUNTUP, TIMER_MODE_COUNTDOWN };
enum TimerState { TIMER_STOPPED, TIMER_RUNNING, TIMER_PAUSED };

static TimerState timerState = TIMER_STOPPED;
static TimerMode timerMode = TIMER_MODE_COUNTUP;
static unsigned long timerStartMillis = 0;
static unsigned long timerPausedMillis = 0;
static unsigned long targetDurationMillis = 0;
static unsigned long lastDisplayUpdate = 0;
#define TIMER_UPDATE_INTERVAL 1000

void setLED(bool red, bool green, bool blue) {
    digitalWrite(LED_RED, red ? LOW : HIGH);
    digitalWrite(LED_GREEN, green ? LOW : HIGH);
    digitalWrite(LED_BLUE, blue ? LOW : HIGH);
}

void blinkLED(bool red, bool green, bool blue, int times, int delayMillis) {
    for (int i = 0; i < times; i++) {
        setLED(red, green, blue);
        delay(delayMillis);
        setLED(false, false, false);
        delay(delayMillis);
    }
}

void alertComplete() {
    for (int i = 0; i < 10; i++) {
        setLED(true, false, false);
        delay(100);
        setLED(false, true, false);
        delay(100);
        setLED(false, false, true);
        delay(100);
    }
    setLED(false, false, false);
}

unsigned long getElapsedMillis() {
    if (timerState == TIMER_STOPPED) return 0;
    else if (timerState == TIMER_PAUSED) return timerPausedMillis;
    else return timerPausedMillis + (millis() - timerStartMillis);
}

unsigned long getRemainingMillis() {
    if (timerMode == TIMER_MODE_COUNTDOWN) {
        unsigned long elapsed = getElapsedMillis();
        if (elapsed >= targetDurationMillis) return 0;
        return targetDurationMillis - elapsed;
    }
    return 0;
}

void formatTime(unsigned long totalSeconds, char *buffer, size_t bufferSize) {
    unsigned long minutes = totalSeconds / 60;
    unsigned long seconds = totalSeconds % 60;
    snprintf(buffer, bufferSize, "%02lu:%02lu", minutes, seconds);
}

void displayTimerStatus() {
    char timeStr[10];
    unsigned long displayMillis = (timerMode == TIMER_MODE_COUNTDOWN) ? getRemainingMillis() : getElapsedMillis();
    formatTime(displayMillis / 1000, timeStr, sizeof(timeStr));
    
    Serial.print("[TIMER] ");
    Serial.print(timeStr);
    if (timerMode == TIMER_MODE_COUNTDOWN) Serial.print(" remaining");
    
    switch (timerState) {
        case TIMER_STOPPED: Serial.println(" (stopped)"); break;
        case TIMER_RUNNING: Serial.println(" (running)"); break;
        case TIMER_PAUSED:  Serial.println(" (paused)"); break;
    }
}

void startTimer() {
    timerMode = TIMER_MODE_COUNTUP;
    timerState = TIMER_RUNNING;
    timerStartMillis = millis();
    timerPausedMillis = 0;
    targetDurationMillis = 0;
    Serial.println("[TIMER] Started counting up");
    displayTimerStatus();
    setLED(false, true, false);
}

void startCountdown(int seconds) {
    timerMode = TIMER_MODE_COUNTDOWN;
    timerState = TIMER_RUNNING;
    timerStartMillis = millis();
    timerPausedMillis = 0;
    targetDurationMillis = (unsigned long)seconds * 1000;
    Serial.print("[TIMER] Counting DOWN from ");
    Serial.print(seconds);
    Serial.println(" seconds");
    displayTimerStatus();
    setLED(false, true, false);
}

void startCountup(int seconds) {
    timerMode = TIMER_MODE_COUNTUP;
    timerState = TIMER_RUNNING;
    timerStartMillis = millis();
    timerPausedMillis = 0;
    targetDurationMillis = (unsigned long)seconds * 1000;
    Serial.print("[TIMER] Counting UP to ");
    Serial.print(seconds);
    Serial.println(" seconds");
    displayTimerStatus();
    setLED(false, true, false);
}

void stopTimer() {
    if (timerState == TIMER_RUNNING) {
        timerPausedMillis += (millis() - timerStartMillis);
        timerState = TIMER_PAUSED;
        Serial.println("[TIMER] Paused");
        displayTimerStatus();
    }
    setLED(true, false, false);
}

void resumeTimer() {
    if (timerState == TIMER_PAUSED) {
        timerState = TIMER_RUNNING;
        timerStartMillis = millis();
        Serial.println("[TIMER] Resumed");
        displayTimerStatus();
        setLED(false, true, false);
    } else if (timerState == TIMER_STOPPED) {
        startTimer();
    }
}

void checkTimer() {
    displayTimerStatus();
    blinkLED(false, false, true, 3, 200);
    if (timerState == TIMER_RUNNING) setLED(false, true, false);
    else if (timerState == TIMER_PAUSED) setLED(true, false, false);
    else setLED(false, false, false);
}

void resetTimer() {
    timerState = TIMER_STOPPED;
    timerPausedMillis = 0;
    targetDurationMillis = 0;
    timerMode = TIMER_MODE_COUNTUP;
    Serial.println("[TIMER] Reset to 00:00");
    displayTimerStatus();
    blinkLED(true, true, true, 3, 150);
    setLED(false, false, false);
}

void checkTimerComplete() {
    if (timerState == TIMER_RUNNING && targetDurationMillis > 0) {
        bool complete = false;
        if (timerMode == TIMER_MODE_COUNTDOWN && getRemainingMillis() == 0) complete = true;
        else if (timerMode == TIMER_MODE_COUNTUP && getElapsedMillis() >= targetDurationMillis) complete = true;
        
        if (complete) {
            timerState = TIMER_STOPPED;
            Serial.println("\n***** TIME'S UP! *****");
            alertComplete();
        }
    }
}

void handleTimerIntent(const char *intent, int32_t num_slots, const char **slots, const char **values) {
    if (strcmp(intent, "start_timer") == 0) {
        if (timerState == TIMER_PAUSED) resumeTimer();
        else startTimer();
    }
    else if (strcmp(intent, "set_timer") == 0) {
        int seconds = 10;
        bool countDown = true;
        for (int32_t i = 0; i < num_slots; i++) {
            if (strcmp(slots[i], "seconds") == 0) seconds = atoi(values[i]);
            else if (strcmp(slots[i], "direction") == 0) countDown = (strcmp(values[i], "down") == 0);
        }
        if (seconds > 0 && seconds <= 99) {
            if (countDown) startCountdown(seconds);
            else startCountup(seconds);
        }
    }
    else if (strcmp(intent, "stop_timer") == 0) stopTimer();
    else if (strcmp(intent, "resume_timer") == 0) resumeTimer();
    else if (strcmp(intent, "check_timer") == 0) checkTimer();
    else if (strcmp(intent, "reset_timer") == 0) resetTimer();
}

static void wake_word_callback(void) {
    Serial.println("Wake word detected!");
    setLED(true, false, true);
    delay(200);
    if (timerState == TIMER_RUNNING) setLED(false, true, false);
    else if (timerState == TIMER_PAUSED) setLED(true, false, false);
    else setLED(false, false, false);
}

static void inference_callback(bool is_understood, const char *intent, int32_t num_slots, const char **slots, const char **values) {
    Serial.println("{");
    Serial.print("    is_understood : '"); Serial.print(is_understood ? "true" : "false"); Serial.println("',");
    if (is_understood) {
        Serial.print("    intent : '"); Serial.print(intent); Serial.println("',");
        if (num_slots > 0) {
            Serial.println("    slots : {");
            for (int32_t i = 0; i < num_slots; i++) {
                Serial.print("        '"); Serial.print(slots[i]); Serial.print("' : '"); Serial.print(values[i]); Serial.println("',");
            }
            Serial.println("    }");
        }
    }
    Serial.println("}");
    Serial.println("");
    
    if (is_understood) {
        handleTimerIntent(intent, num_slots, slots, values);
    }
}

static void print_error_message(char **message_stack, int32_t message_stack_depth) {
    for (int32_t i = 0; i < message_stack_depth; i++) {
        Serial.println(message_stack[i]);
    }
}

static void error_handler() {
    char **message_stack = NULL;
    int32_t message_stack_depth = 0;
    pv_status_t error_status = pv_get_error_stack(&message_stack, &message_stack_depth);
    if (error_status != PV_STATUS_SUCCESS) {
        Serial.println("Unable to get Rhino error state");
        while (1);
    }
    print_error_message(message_stack, message_stack_depth);
    pv_free_error_stack(message_stack);
    while (1);
}


static bool process_porcupine(pv_porcupine_t *ppn_handle, const int16_t *buffer) {
    int32_t keyword_index = -1;
    const pv_status_t status = pv_porcupine_process(ppn_handle, buffer, &keyword_index);
    if (status != PV_STATUS_SUCCESS) {
        Serial.print("Porcupine process failed with ");
        Serial.println(pv_status_to_string(status));
        error_handler();
    }

    bool found_keyword = keyword_index != -1;
    if (found_keyword) {
        wake_word_callback();
    }

    return found_keyword;
}

static bool process_rhino(pv_rhino_t *rhn_handle, const int16_t *buffer) {
    bool is_finalized = false;
    pv_status_t status = pv_rhino_process(rhn_handle, buffer, &is_finalized);
    if (status != PV_STATUS_SUCCESS) {
        Serial.print("Rhino process failed with ");
        Serial.println(pv_status_to_string(status));
        error_handler();
    }

    if (!is_finalized) {
        return false;
    }

    bool is_understood = false;
    status = pv_rhino_is_understood(rhn_handle, &is_understood);
    if (status != PV_STATUS_SUCCESS) {
        Serial.print("Rhino is_understood failed with ");
        Serial.println(pv_status_to_string(status));
        error_handler();
    }

    if (is_understood) {
        const char *intent = NULL;
        int32_t num_slots = 0;
        const char **slots = NULL;
        const char **values = NULL;

        status = pv_rhino_get_intent(
                rhn_handle,
                &intent,
                &num_slots,
                &slots,
                &values);
        if (status != PV_STATUS_SUCCESS) {
            Serial.print("Rhino get_intent failed with ");
            Serial.println(pv_status_to_string(status));
            error_handler();
        }

        inference_callback(is_understood, intent, num_slots, slots, values);

        status = pv_rhino_free_slots_and_values(rhn_handle, slots, values);
        if (status != PV_STATUS_SUCCESS) {
            Serial.print("Rhino free_slots_and_values failed with ");
            Serial.println(pv_status_to_string(status));
            error_handler();
        }
    } else {
        inference_callback(is_understood, NULL, 0, NULL, NULL);
    }

    status = pv_rhino_reset(rhn_handle);
    if (status != PV_STATUS_SUCCESS) {
        Serial.print("Rhino reset failed with ");
        Serial.println(pv_status_to_string(status));
        error_handler();
    }

    return true;
}

void setup() {
    Serial.begin(9600);
    while (!Serial);

    pinMode(LED_RED, OUTPUT);
    pinMode(LED_GREEN, OUTPUT);
    pinMode(LED_BLUE, OUTPUT);
    setLED(false, false, false);

    pv_status_t status = picovoice::porcupine::pv_audio_rec_init();
    if (status != PV_STATUS_SUCCESS) {
        Serial.print("Audio init failed with ");
        Serial.println(pv_status_to_string(status));
        while (1);
    }

    status = pv_porcupine_init(
            ACCESS_KEY,
            MEMORY_BUFFER_SIZE,
            ppn_memory_buffer,
            1,
            &KEYWORD_MODEL_SIZES,
            &KEYWORD_MODELS,
            &PORCUPINE_SENSITIVITY,
            &ppn_handle);
    if (status != PV_STATUS_SUCCESS) {
        Serial.print("Porcupine init failed with ");
        Serial.println(pv_status_to_string(status));
        error_handler();
    }

    status = pv_rhino_init(
            ACCESS_KEY,
            rhn_memory_buffer,
            MEMORY_BUFFER_SIZE,
            CONTEXT_ARRAY,
            sizeof(CONTEXT_ARRAY),
            RHINO_SENSITIVITY,
            RHINO_ENDPOINT_DURATION_SEC,
            RHINO_REQUIRE_ENDPOINT,
            &rhn_handle);
    if (status != PV_STATUS_SUCCESS) {
        Serial.print("Rhino init failed with ");
        Serial.println(pv_status_to_string(status));
        error_handler();
    }

    const char *rhino_context = NULL;
    status = pv_rhino_context_info(rhn_handle, &rhino_context);
    if (status != PV_STATUS_SUCCESS) {
        Serial.print("Retrieving context info failed with");
        Serial.println(pv_status_to_string(status));
        error_handler();
    }
    Serial.println("Wake word: 'Hey Assistant'");
    Serial.println(rhino_context);
}

bool wakeword_heard = false;
bool inference_finalized = false;

void loop() {
    const int16_t *buffer = picovoice::porcupine::pv_audio_rec_get_new_buffer();
    if (buffer) {
        if (!wakeword_heard) {
            wakeword_heard = process_porcupine(ppn_handle, buffer);
        }
        else if (!inference_finalized) {
            inference_finalized = process_rhino(rhn_handle, buffer);
        }
    }
    if (wakeword_heard && inference_finalized) {
        wakeword_heard = false;
        inference_finalized = false;
    }

    if (timerState == TIMER_RUNNING) {
        unsigned long currentMillis = millis();
        if (currentMillis - lastDisplayUpdate >= TIMER_UPDATE_INTERVAL) {
            lastDisplayUpdate = currentMillis;
            displayTimerStatus();
            checkTimerComplete();
        }
    }
}

Upload the full voice assistant code to your Arduino and run the voice-controlled timer.

Test the Voice Assistant with these commands:

"Hey Assistant, start the timer"
"Hey Assistant, count down for 30 seconds"
"Hey Assistant, pause timer"
"Hey Assistant, check timer"

Watch the LED colors change and monitor status updates in the Serial Monitor

Troubleshooting

Upload fails with "No device found"

Try a different USB cable (must support data, not just charging)
Double-tap reset button on Arduino for bootloader mode

Wake word not detecting

Check Serial Monitor for error messages
Verify AccessKey is correct in sketch
Ensure models were trained with correct UUID

Intent not understood

Use exact phrases from your Rhino context YAML
Check that context was trained with your Arduino's UUID
View Serial Monitor to see what Rhino heard

Compilation errors

Ensure AccessKey is in quotes: "your-key-here"
Verify pv_params.h contains both KEYWORD_ARRAY and CONTEXT_ARRAY

Extend Your Arduino Voice Assistant: What to Build Next

Add More Voice Commands

Expand your timer context with additional intents:

Multiple timer slots - "set study timer," "set workout timer"
Custom notifications - "alert me when timer reaches 5 seconds"

Integrate with Hardware

Connect additional components:

Relay modules - Control appliances, lights, or actuators
LCD displays - Visual timer display
Sensors - Voice-activated data logging ("record temperature")

Build on Multiple Platforms

Explore additional recipes in pico-cookbook:

LLM Voice Assistant — Add local LLM intelligence with picoLLM
Android/iOS — Build mobile voice assistants
Python — Build desktop voice applications
STM32 — Build with other ARM Cortex-M microcontrollers

Resources

You can start building your own commercial or non-commercial projects leveraging Picovoice's self-service Console.

Start Building

Frequently Asked Questions

Can I add multiple wake words to the project?

Yes. Porcupine Wake Word supports using multiple wake words simultaneously. You can also create contextual wake words that activate different features.

Can I use this commercially?

Yes. Picovoice offers commercial licenses for production deployments. Free tier includes development and personal projects. Visit pricing for commercial licensing.

Does this support languages other than English?

Yes. Picovoice supports multiple languages including Spanish, French, German, and more. Install the appropriate language library (e.g., Picovoice_ES for Spanish).