Documentation

// Voice Recognition Module V3 - Arduino Example
// Module TXD -> D2, Module RXD -> D3, VCC -> 5V, GND -> GND
// Library: Elechouse VoiceRecognitionV3 (github.com/elechouse/VoiceRecognitionV3)
// Train records 0-2 first with the vr_sample_train example.

#include <SoftwareSerial.h>
#include "VoiceRecognitionV3.h"

VR myVR(2, 3);   // RX = D2 (from module TXD), TX = D3 (to module RXD)

uint8_t records[7];
uint8_t buf[64];

void setup() {
  Serial.begin(115200);
  myVR.begin(9600);

  if (myVR.clear() == 0) {
    Serial.println("Recognizer cleared.");
  } else {
    Serial.println("Module not found - check wiring.");
    while (1);
  }

  // Load trained records 0, 1, 2 into the active recognizer
  if (myVR.load((uint8_t)0) >= 0) Serial.println("Record 0 loaded");
  if (myVR.load((uint8_t)1) >= 0) Serial.println("Record 1 loaded");
  if (myVR.load((uint8_t)2) >= 0) Serial.println("Record 2 loaded");

  Serial.println("Speak one of your trained commands...");
}

void loop() {
  int ret = myVR.recognize(buf, 50);

  if (ret > 0) {
    // buf[1] holds the record number that was recognized
    switch (buf[1]) {
      case 0:
        Serial.println("Command 0 recognized!");
        // digitalWrite(LED_BUILTIN, HIGH);  // your action here
        break;
      case 1:
        Serial.println("Command 1 recognized!");
        break;
      case 2:
        Serial.println("Command 2 recognized!");
        break;
      default:
        Serial.println("Record not handled");
    }
  }
}

// Voice Recognition Module V3 - ESP32 Example (raw protocol)
// Module TXD -> GPIO 16 via divider, Module RXD -> GPIO 17, VCC -> VIN
// Train the records first using an Arduino and the Elechouse library -
// the voiceprints stay stored on the module.

HardwareSerial vrSerial(2);  // UART2

void loadRecord(uint8_t rec) {
  // Frame: AA | LEN | 30 (load) | record | 0A
  uint8_t cmd[5] = {0xAA, 0x02, 0x30, rec, 0x0A};
  cmd[1] = 2;  // LEN = command + data bytes
  vrSerial.write(cmd, 5);
  delay(50);
}

void setup() {
  Serial.begin(115200);
  vrSerial.begin(9600, SERIAL_8N1, 16, 17);
  delay(500);

  // Load trained records 0-2 into the recognizer
  loadRecord(0);
  loadRecord(1);
  loadRecord(2);

  Serial.println("Speak one of your trained commands...");
}

void loop() {
  // Recognition frames arrive as: AA | LEN | 0D | data... | 0A
  static uint8_t frame[32];
  static int pos = -1;

  while (vrSerial.available()) {
    uint8_t b = vrSerial.read();

    if (pos < 0) {
      if (b == 0xAA) { pos = 0; frame[pos++] = b; }
    } else {
      frame[pos++] = b;
      if (b == 0x0A || pos >= 32) {
        // frame[2] = 0x0D means "voice recognized";
        // frame[4] holds the record number
        if (pos > 5 && frame[2] == 0x0D) {
          Serial.printf("Recognized record #%d\n", frame[4]);
        }
        pos = -1;
      }
    }
  }
}

#!/usr/bin/env python3
# Voice Recognition Module V3 - Raspberry Pi Example (raw protocol)
# Module TXD -> GPIO 15 via divider, Module RXD -> GPIO 14, VCC -> 5V
# Setup: sudo raspi-config (disable serial console, enable serial port)
#        pip3 install pyserial
# Train the records first with an Arduino - they stay on the module.

import time
import serial

ser = serial.Serial('/dev/serial0', baudrate=9600, timeout=0.1)

def load_record(rec):
    # Frame: AA | LEN | 30 (load) | record | 0A
    ser.write(bytes([0xAA, 0x02, 0x30, rec, 0x0A]))
    time.sleep(0.05)

# Load trained records 0-2 into the active recognizer
for r in (0, 1, 2):
    load_record(r)

print('Speak one of your trained commands (Ctrl+C to stop)...')

buffer = bytearray()

try:
    while True:
        data = ser.read(32)
        if data:
            buffer.extend(data)

            # Complete frames start with 0xAA and end with 0x0A
            while 0xAA in buffer and 0x0A in buffer[buffer.index(0xAA):]:
                start = buffer.index(0xAA)
                end = buffer.index(0x0A, start)
                frame = buffer[start:end + 1]
                del buffer[:end + 1]

                # frame[2] == 0x0D means "voice recognized";
                # frame[4] holds the record number
                if len(frame) > 5 and frame[2] == 0x0D:
                    print('Recognized record #{}'.format(frame[4]))
        time.sleep(0.02)

except KeyboardInterrupt:
    print('Stopped by user')
finally:
    ser.close()

# Voice Recognition Module V3 - Pico MicroPython Example (raw protocol)
# Module TXD -> GP1 via divider, Module RXD -> GP0, VCC -> VBUS
# Train the records first with an Arduino - they stay on the module.

from machine import UART, Pin
import time

uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1), timeout=100)

def load_record(rec):
    # Frame: AA | LEN | 30 (load) | record | 0A
    uart.write(bytes([0xAA, 0x02, 0x30, rec, 0x0A]))
    time.sleep_ms(50)

# Load trained records 0-2 into the active recognizer
for r in (0, 1, 2):
    load_record(r)

print("Speak one of your trained commands...")

buffer = bytearray()

while True:
    data = uart.read()
    if data:
        buffer.extend(data)

        # Complete frames start with 0xAA and end with 0x0A
        while 0xAA in buffer:
            start = buffer.index(0xAA)
            end = buffer.find(b'\n', start)   # 0x0A terminator
            if end < 0:
                break
            frame = buffer[start:end + 1]
            del buffer[:end + 1]

            # frame[2] == 0x0D means "voice recognized";
            # frame[4] holds the record number
            if len(frame) > 5 and frame[2] == 0x0D:
                print("Recognized record #", frame[4])
    time.sleep_ms(20)