Altium
Arduino Projects

Voice Recognition Module v3.1, multi-language commands training Arduino

Description:

voice recognition

voice recognition module V3.1– This Tutorial is about the Voice Recognition module v3.1. In this tutorial, you will learn how to train your Recognition module using different languages, you will also learn how to delete a voice command and replace It with another voice command.  In this tutorial, we will cover all the basics. In my future tutorials, I will be using the same voice recognition module for controlling home appliances, for controlling robots, for controlling a wheelchair and so on. you can also read my article on Tongue Controlled Wheelchair.

This is one of the best speech recognition modules available in the market and can be easily used with Arduino Uno and mega. This speech recognition module v3.1 can be easily used with the Arduino to control anything you want. For more detailed explanation watch video available at the end of this Article.


Amazon Links:

12v Adaptor:

Arduino Uno

Arduino Nano

Mega 2560:

Voice Recognition Module V3.1

Other Tools and Components:

Top Arduino Sensors:

Super Starter kit for Beginners

Digital Oscilloscopes

Variable Supply

Digital Multimeter

Soldering iron kits

PCB small portable drill machines

*Please Note: These are affiliate links. I may make a commission if you buy the components through these links. I would appreciate your support in this way!

Voice recognition module V3.1:

voice recognition

This is the speech recognition module V3.1, as you can see clearly on the bottom side, we have GND, VCC, RXD, and TXD. We will solder male headers over here so that it can be easily interfaced with Arduino.

voice recognition

So this is how the voice recognition module looks after soldering the male headers. After the soldering is done, make sure you check the short circuit, for this you can use a digital multimeter. Set the Multimeter on the continuity and check all the pins soldered. Now it’s ready for the interfacing. This voice recognition module can be interfaced with the Arduino or Mega using male to female type jumper wires.


voice recognition

  1. Connect the ground of the Voice recognition module with the Arduino’s Ground.
  2. Connect the VCC of the voice recognition module with the Arduino’s 5v.
  3. Connect the RXD of the voice recognition module with pin 3 of the Arduino.
  4. Connect the TXD Pin of the voice recognition module with pin2 of the Arduino.

 Now connect a USB cable and connect the Arduino with your laptop or PC. After you connect the Arduino Uno with your laptop or Computer open the desired program, upload the code into the Arduino by clicking on the upload button and wait for a while. After you are done with the uploading then the next step is to open the Serial monitor, follow the commands and start training.

Make sure the room you are sitting in is noise free, as the background noises can really effect the command’s training and you will get errors. While recording the voice commands relax your body, try not to change your voice tone, do recording in the normal way.

Voice recognition module Commands training:

/** ******************************************************
 * @file    vr_sample_train.ino
 * @author  JiapengLi
 * @brief   This file provides a demostration on 
 * how to train VoiceRecognitionModule to record your voice
 ******************************************************************************
 * @note:
 * Use serial command to control VoiceRecognitionModule. '
 * All commands are case insensitive. Default serial baud rate 115200.
 * 
 * COMMAND        FORMAT                        EXAMPLE                    Comment
 * 
 train 0 2 45               Train records
load 0 51 2 3              Load records

clear                         clear                      remove all records in  Recognizer

 * record         record / record (r0) (r1)...  record / record 0 79       Check record train status
 * vr             vr                            vr                         Check recognizer status
 * getsig         getsig (r)                    getsig 0                   Get signature of record (r)
 * sigtrain       sigtrain (r) (sig)            sigtrain 0 ZERO            Train one record(r) with signature(sig)
 * settings       settings                      settings                   Check current system settings
 ************************************************************************/

Voice recognition module Arduino Programming:

In this project, two programs will be used. One program will be used for the voice commands training and another program will be used for the controlling. Before you start the programming, first of all, make sure that you download the necessary library for the voice recognition module.


Link: https://github.com/elechouse/VoiceRecognitionV3

Voice recognition Module Commands Training Arduino Program:

#include <SoftwareSerial.h>
#include “VoiceRecognitionV3.h”

/**
* Connection
* Arduino VoiceRecognitionModule
* 2 ——-> TX
* 3 ——-> RX
*/
VR myVR(2,3); // 2:RX 3:TX, you can choose your favourite pins.

/***************************************************************************/
/** declare print functions */
void printSeperator();
void printSignature(uint8_t *buf, int len);
void printVR(uint8_t *buf);
void printLoad(uint8_t *buf, uint8_t len);
void printTrain(uint8_t *buf, uint8_t len);
void printCheckRecognizer(uint8_t *buf);
void printUserGroup(uint8_t *buf, int len);
void printCheckRecord(uint8_t *buf, int num);
void printCheckRecordAll(uint8_t *buf, int num);
void printSigTrain(uint8_t *buf, uint8_t len);
void printSystemSettings(uint8_t *buf, int len);
void printHelp(void);

/***************************************************************************/
// command analyze part
#define CMD_BUF_LEN 64+1
#define CMD_NUM 10
typedef int (*cmd_function_t)(int, int);
uint8_t cmd[CMD_BUF_LEN];
uint8_t cmd_cnt;
uint8_t *paraAddr;
int receiveCMD();
int checkCMD(int len);
int checkParaNum(int len);
int findPara(int len, int paraNum, uint8_t **addr);
int compareCMD(uint8_t *para1 , uint8_t *para2, int len);

int cmdTrain(int len, int paraNum);
int cmdLoad(int len, int paraNum);
int cmdTest(int len, int paraNum);
int cmdVR(int len, int paraNum);
int cmdClear(int len, int paraNum);
int cmdRecord(int len, int paraNum);
int cmdSigTrain(int len, int paraNum);
int cmdGetSig(int len, int paraNum);
int cmdSettings(int len, int paraNum);
int cmdHelp(int len, int paraNum);
/** cmdList, cmdLen, cmdFunction has correspondence */
const char cmdList[CMD_NUM][10] = { // command list table
{
“train” }
,
{
“load” }
,
{
“clear” }
,
{
“vr” }
,
{
“record” }
,
{
“sigtrain” }
,
{
“getsig” }
,
{
“Settings” }
,
{
“test” }
,
{
“help” }
,
};
const char cmdLen[CMD_NUM]= { // command length
5, // {“train”},
4, // {“load”},
5, // {“clear”},
2, // {“vr”},
6, // {“record”},
8, // {“sigtrain”},
6, // {“getsig”},
8, // {“Settings”},
4, // {“test”},
4, // {“help”}
};
cmd_function_t cmdFunction[CMD_NUM]={ // command handle fuction(function pointer table)
cmdTrain,
cmdLoad,
cmdClear,
cmdVR,
cmdRecord,
cmdSigTrain,
cmdGetSig,
cmdSettings,
cmdTest,
cmdHelp,
};

/***************************************************************************/
/** temprory data */
uint8_t buf[255];
uint8_t records[7]; // save record

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

/** initialize */
Serial.begin(115200);
Serial.println(F(“Elechouse Voice Recognition V3 Module \”train\” sample.”));

printSeperator();
Serial.println(F(“Usage:”));
printSeperator();
printHelp();
printSeperator();
cmd_cnt = 0;
}

void loop(void)
{
int len, paraNum, paraLen, i;

/** receive Serial command */
len = receiveCMD();
if(len>0){
/** check if the received command is valid */
if(!checkCMD(len)){

/** check parameter number of the received command */
paraNum = checkParaNum(len);

/** display the receved command back */
Serial.write(cmd, len);

/** find the first parameter */
paraLen = findPara(len, 1, &paraAddr);

/** compare the received command with command in the list */
for(i=0; i<CMD_NUM; i++){
/** compare command length */
if(paraLen == cmdLen[i]){
/** compare command content */
if( compareCMD(paraAddr, (uint8_t *)cmdList[i], paraLen) == 0 ){
/** call command function */
if( cmdFunction[i](len, paraNum) != 0){
printSeperator();
Serial.println(F(“Command Format Error!”));
printSeperator();
}
break;
}
}
}

/** command is not supported*/
if(i == CMD_NUM){
printSeperator();
Serial.println(F(“Unkonwn command”));
printSeperator();
}
}
else{
/** received command is invalid */
printSeperator();
Serial.println(F(“Command format error”));
printSeperator();
}
}

/** try to receive recognize result */
int ret;
ret = myVR.recognize(buf, 50);
if(ret>0){
/** voice recognized, print result */
printVR(buf);
}
}

/**
* @brief receive command from Serial.
* @param NONE.
* @retval command length, if no command receive return -1.
*/
int receiveCMD()
{
int ret;
int len;
unsigned long start_millis;
start_millis = millis();
while(1){
ret = Serial.read();
if(ret>0){
start_millis = millis();
cmd[cmd_cnt] = ret;
if(cmd[cmd_cnt] == ‘\n’){
len = cmd_cnt+1;
cmd_cnt = 0;
return len;
}
cmd_cnt++;
if(cmd_cnt == CMD_BUF_LEN){
cmd_cnt = 0;
return -1;
}
}

if(millis() – start_millis > 100){
cmd_cnt = 0;
return -1;
}
}
}

/**
* @brief compare two commands, case insensitive.
* @param para1 –> command buffer 1
* para2 –> command buffer 2
* len –> buffer length
* @retval 0 –> equal
* -1 –> unequal
*/
int compareCMD(uint8_t *para1 , uint8_t *para2, int len)
{
int i;
uint8_t res;
for(i=0; i<len; i++){
res = para2[i] – para1[i];
if(res != 0 && res != 0x20){
res = para1[i] – para2[i];
if(res != 0 && res != 0x20){
return -1;
}
}
}
return 0;
}

/**
* @brief Check command format.
* @param len –> command length
* @retval 0 –> command is valid
* -1 –> command is invalid
*/
int checkCMD(int len)
{
int i;
for(i=0; i<len; i++){
if(cmd[i] > 0x1F && cmd[i] < 0x7F){

}
else if(cmd[i] == ‘\t’ || cmd[i] == ‘ ‘ || cmd[i] == ‘\r’ || cmd[i] == ‘\n’){

}
else{
return -1;
}
}
return 0;
}

/**
* @brief Check the number of parameters in the command
* @param len –> command length
* @retval number of parameters
*/
int checkParaNum(int len)
{
int cnt=0, i;
for(i=0; i<len; ){
if(cmd[i]!=’\t’ && cmd[i]!=’ ‘ && cmd[i] != ‘\r’ && cmd[i] != ‘\n’){
cnt++;
while(cmd[i] != ‘\t’ && cmd[i] != ‘ ‘ && cmd[i] != ‘\r’ && cmd[i] != ‘\n’){
i++;
}
}
i++;
}
return cnt;
}

/**
* @brief Find the specified parameter.
* @param len –> command length
* paraIndex –> parameter index
* addr –> return value. position of the parameter
* @retval length of specified parameter
/
int findPara(int len, int paraIndex, uint8_t **addr)
{
int cnt=0, i, paraLen;
uint8_t dt;
for(i=0; i<len; ){
dt = cmd[i];
if(dt!=’\t’ && dt!=’ ‘){
cnt++;
if(paraIndex == cnt){
addr = cmd+i;
paraLen = 0;
while(cmd[i] != ‘\t’ && cmd[i] != ‘ ‘ && cmd[i] != ‘\r’ && cmd[i] != ‘\n’){
i++;
paraLen++;
}
return paraLen;
}
else{
while(cmd[i] != ‘\t’ && cmd[i] != ‘ ‘ && cmd[i] != ‘\r’ && cmd[i] != ‘\n’){
i++;
}
}
}
else{
i++;
}
}
return -1;
}

int cmdHelp(int len, int paraNum)
{
if(paraNum != 1){
return -1;
}
printSeperator();
printHelp();
printSeperator();
return 0;
}

/**
* @brief Handle “train” command
* @param len –> command length
* paraNum –> number of parameters
* @retval 0 –> success
* -1 –> Command format error
*/
int cmdTrain(int len, int paraNum)
{
int i, ret;
if(paraNum < 2 || paraNum > 8 ){
return -1;
}

for(i=2; i<=paraNum; i++){
findPara(len, i, &paraAddr);
records[i-2] = atoi((char *)paraAddr);
if(records[i-2] == 0 && *paraAddr != ‘0’){
return -1;
}
}
printSeperator();
ret = myVR.train(records, paraNum-1, buf);
// ret = myVR.train(records, paraNum-1);
if(ret >= 0){
printTrain(buf, ret);
}
else if(ret == -1){
Serial.println(F(“Train failed.”));
}
else if(ret == -2){
Serial.println(F(“Train Timeout.”));
}
printSeperator();
return 0;
}

/**
* @brief Handle “load” command
* @param len –> command length
* paraNum –> number of parameters
* @retval 0 –> success
* -1 –> Command format error
*/
int cmdLoad(int len, int paraNum)
{
int i, ret;
if(paraNum < 2 || paraNum > 8 ){
return -1;
}

for(i=2; i<=paraNum; i++){
findPara(len, i, &paraAddr);
records[i-2] = atoi((char *)paraAddr);
if(records[i-2] == 0 && *paraAddr != ‘0’){
return -1;
}
}
// myVR.writehex(records, paraNum-1);
ret = myVR.load(records, paraNum-1, buf);
printSeperator();
if(ret >= 0){
printLoad(buf, ret);
}
else{
Serial.println(F(“Load failed or timeout.”));
}
printSeperator();
return 0;
}

/**
* @brief Handle “clear” command
* @param len –> command length
* paraNum –> number of parameters
* @retval 0 –> success
* -1 –> Command format error
*/
int cmdClear(int len, int paraNum)
{
if(paraNum != 1){
return -1;
}
if(myVR.clear() == 0){
printSeperator();
Serial.println(F(“Recognizer cleared.”));
printSeperator();
}
else{
printSeperator();
Serial.println(F(“Clear recognizer failed or timeout.”));
printSeperator();
}
return 0;
}

/**
* @brief Handle “vr” command
* @param len –> command length
* paraNum –> number of parameters
* @retval 0 –> success
* -1 –> Command format error
*/
int cmdVR(int len, int paraNum)
{
int ret;
if(paraNum != 1){
return -1;
}
ret = myVR.checkRecognizer(buf);
if(ret<=0){
printSeperator();
Serial.println(F(“Check recognizer failed or timeout.”));
printSeperator();
return 0;
}
printSeperator();
printCheckRecognizer(buf);
printSeperator();
return 0;
}

/**
* @brief Handle “record” command
* @param len –> command length
* paraNum –> number of parameters
* @retval 0 –> success
* -1 –> Command format error
*/
int cmdRecord(int len, int paraNum)
{
int ret;
if(paraNum == 1){
ret = myVR.checkRecord(buf);
printSeperator();
if(ret>=0){
printCheckRecordAll(buf, ret);
}
else{
Serial.println(F(“Check record failed or timeout.”));
}
printSeperator();
}
else if(paraNum < 9){
for(int i=2; i<=paraNum; i++){
findPara(len, i, &paraAddr);
records[i-2] = atoi((char *)paraAddr);
if(records[i-2] == 0 && *paraAddr != ‘0’){
return -1;
}
}

ret = myVR.checkRecord(buf, records, paraNum-1); // auto clean duplicate records
printSeperator();
if(ret>=0){
printCheckRecord(buf, ret);
}
else{
Serial.println(F(“Check record failed or timeout.”));
}
printSeperator();
}
else{
return -1;
}
return 0;
}

/**
* @brief Handle “sigtrain” command
* @param len –> command length
* paraNum –> number of parameters
* @retval 0 –> success
* -1 –> Command format error
*/
int cmdSigTrain(int len, int paraNum)
{
int ret, sig_len;
uint8_t *lastAddr;
if(paraNum < 2){
return -1;
}

findPara(len, 2, &paraAddr);
records[0] = atoi((char *)paraAddr);
if(records[0] == 0 && *paraAddr != ‘0’){
return -1;
}

findPara(len, 3, &paraAddr);
sig_len = findPara(len, paraNum, &lastAddr);
sig_len +=( (unsigned int)lastAddr – (unsigned int)paraAddr );

printSeperator();
ret = myVR.trainWithSignature(records[0], paraAddr, sig_len, buf);
// ret = myVR.trainWithSignature(records, paraNum-1);
if(ret >= 0){
printSigTrain(buf, ret);
}
else{
Serial.println(F(“Train with signature failed or timeout.”));
}
printSeperator();

return 0;
}

/**
* @brief Handle “getsig” command
* @param len –> command length
* paraNum –> number of parameters
* @retval 0 –> success
* -1 –> Command format error
*/
int cmdGetSig(int len, int paraNum)
{
int ret;
if(paraNum != 2){
return -1;
}

findPara(len, 2, &paraAddr);
records[0] = atoi((char *)paraAddr);
if(records[0] == 0 && *paraAddr != ‘0’){
return -1;
}

ret = myVR.checkSignature(records[0], buf);

printSeperator();
if(ret == 0){
Serial.println(F(“Signature isn’t set.”));
}
else if(ret > 0){
Serial.print(F(“Signature:”));
printSignature(buf, ret);
Serial.println();
}
else{
Serial.println(F(“Get sig error or timeout.”));
}
printSeperator();

return 0;
}

/**
* @brief Handle “test” command
* @param len –> command length
* paraNum –> number of parameters
* @retval 0 –> success
* -1 –> Command format error
*/
int cmdTest(int len, int paraNum)
{
printSeperator();
Serial.println(F(“TEST is not supported.”));
printSeperator();
return 0;
}

int cmdSettings(int len, int paraNum)
{
int ret;
if(paraNum != 1){
return -1;
}
ret = myVR.checkSystemSettings(buf);
if( ret > 0){
printSeperator();
printSystemSettings(buf, ret);
printSeperator();
}
else{
printSeperator();
Serial.println(F(“Check system settings error or timeout”));
printSeperator();
}
return 0;
}

/*****************************************************************************/
/**
* @brief Print signature, if the character is invisible,
* print hexible value instead.
* @param buf –> command length
* len –> number of parameters
*/
void printSignature(uint8_t *buf, int len)
{
int i;
for(i=0; i<len; i++){
if(buf[i]>0x19 && buf[i]<0x7F){
Serial.write(buf[i]);
}
else{
Serial.print(F(“[“));
Serial.print(buf[i], HEX);
Serial.print(F(“]”));
}
}
}

/**
* @brief Print signature, if the character is invisible,
* print hexible value instead.
* @param buf –> VR module return value when voice is recognized.
* buf[0] –> Group mode(FF: None Group, 0x8n: User, 0x0n:System
* buf[1] –> number of record which is recognized.
* buf[2] –> Recognizer index(position) value of the recognized record.
* buf[3] –> Signature length
* buf[4]~buf[n] –> Signature
*/
void printVR(uint8_t *buf)
{
Serial.println(F(“VR Index\tGroup\tRecordNum\tSignature”));

Serial.print(buf[2], DEC);
Serial.print(F(“\t\t”));

if(buf[0] == 0xFF){
Serial.print(F(“NONE”));
}
else if(buf[0]&0x80){
Serial.print(F(“UG “));
Serial.print(buf[0]&(~0x80), DEC);
}
else{
Serial.print(F(“SG “));
Serial.print(buf[0], DEC);
}
Serial.print(F(“\t”));

Serial.print(buf[1], DEC);
Serial.print(F(“\t\t”));
if(buf[3]>0){
printSignature(buf+4, buf[3]);
}
else{
Serial.print(F(“NONE”));
}
Serial.println(F(“\r\n”));
}

/**
* @brief Print seperator. Print 80 ‘-‘.
*/
void printSeperator()
{
for(int i=0; i<80; i++){
Serial.write(‘-‘);
}
Serial.println();
}

/**
* @brief Print recoginizer status.
* @param buf –> VR module return value when voice is recognized.
* buf[0] –> Number of valid voice records in recognizer
* buf[i+1] –> Record number.(0xFF: Not loaded(Nongroup mode), or not set (Group mode)) (i= 0, 1, … 6)
* buf[8] –> Number of all voice records in recognizer
* buf[9] –> Valid records position indicate.
* buf[10] –> Group mode indicate(FF: None Group, 0x8n: User, 0x0n:System)
*/
void printCheckRecognizer(uint8_t *buf)
{
Serial.print(F(“All voice records in recognizer: “));
Serial.println(buf[8], DEC);
Serial.print(F(“Valid voice records in recognizer: “));
Serial.println(buf[0], DEC);
if(buf[10] == 0xFF){
Serial.println(F(“VR is not in group mode.”));
}
else if(buf[10]&0x80){
Serial.print(F(“VR is in user group mode:”));
Serial.println(buf[10]&0x7F, DEC);
}
else{
Serial.print(F(“VR is in system group mode:”));
Serial.println(buf[10], DEC);
}
Serial.println(F(“VR Index\tRecord\t\tComment”));
for(int i=0; i<7; i++){
Serial.print(i, DEC);
Serial.print(F(“\t\t”));
if(buf[i+1] == 0xFF){
if(buf[10] == 0xFF){
Serial.print(F(“Unloaded\tNONE”));
}
else{
Serial.print(F(“Not Set\t\tNONE”));
}
}
else{
Serial.print(buf[i+1], DEC);
Serial.print(F(“\t\t”));
if(buf[9]&(1<<i)){
Serial.print(F(“Valid”));
}
else{
Serial.print(F(“Untrained”));
}
}

Serial.println();
}
}

/**
* @brief Print record train status.
* @param buf –> Check record command return value
* buf[0] –> Number of checked records
* buf[2i+1] –> Record number.
* buf[2i+2] –> Record train status. (00: untrained, 01: trained, FF: record value out of range)
* (i = 0 ~ buf[0]-1 )
* num –> Number of trained records
*/
void printCheckRecord(uint8_t *buf, int num)
{
Serial.print(F(“Check “));
Serial.print(buf[0], DEC);
Serial.println(F(” records.”));

Serial.print(num, DEC);
if(num>1){
Serial.println(F(” records trained.”));
}
else{
Serial.println(F(” record trained.”));
}

for(int i=0; i<buf[0]*2; i += 2){
Serial.print(buf[i+1], DEC);
Serial.print(F(“\t–>\t”));
switch(buf[i+2]){
case 0x01:
Serial.print(F(“Trained”));
break;
case 0x00:
Serial.print(F(“Untrained”));
break;
case 0xFF:
Serial.print(F(“Record value out of range”));
break;
default:
Serial.print(F(“Unknown Stauts”));
break;
}
Serial.println();
}
}

/**
* @brief Print record train status.
* @param buf –> Check record command return value
* buf[0] –> Number of checked records
* buf[2i+1] –> Record number.
* buf[2i+2] –> Record train status. (00: untrained, 01: trained, FF: record value out of range)
* (i = 0 ~ buf[0]-1 )
* num –> Number of trained records
*/
void printCheckRecordAll(uint8_t *buf, int num)
{
Serial.print(F(“Check 255”));
Serial.println(F(” records.”));

Serial.print(num, DEC);
if(num>1){
Serial.println(F(” records trained.”));
}
else{
Serial.println(F(” record trained.”));
}
myVR.writehex(buf, 255);
for(int i=0; i<255; i++){
if(buf[i] == 0xF0){
continue;
}
Serial.print(i, DEC);
Serial.print(F(“\t–>\t”));
switch(buf[i]){
case 0x01:
Serial.print(F(“Trained”));
break;
case 0x00:
Serial.print(F(“Untrained”));
break;
case 0xFF:
Serial.print(F(“Record value out of range”));
break;
default:
Serial.print(F(“Unknown Stauts”));
break;
}
Serial.println();
}
}

/**
* @brief Print check user group result.
* @param buf –> Check record command return value
* buf[8i] –> group number.
* buf[8i+1] –> group position 0 status.
* buf[8i+2] –> group position 1 status.
* … …
* buf[8i+6] –> group position 5 status.
* buf[8i+7] –> group position 6 status.
* (i = 0 ~ len)
* len –> number of checked groups
/
void printUserGroup(uint8_t *buf, int len)
{
int i, j;
Serial.println(F(“Check User Group:”));
for(i=0; i<len; i++){
Serial.print(F(“Group:”));
Serial.println(buf[8
i]);
for(j=0; j<7; j++){
if(buf[8i+1+j] == 0xFF){
Serial.print(F(“NONE\t”));
}
else{
Serial.print(buf[8
i+1+j], DEC);
Serial.print(F(“\t”));
}
}
Serial.println();
}
}

/**
* @brief Print “load” command return value.
* @param buf –> “load” command return value
* buf[0] –> number of records which are load successfully.
* buf[2i+1] –> record number
* buf[2i+2] –> record load status.
* 00 –> Loaded
* FC –> Record already in recognizer
* FD –> Recognizer full
* FE –> Record untrained
* FF –> Value out of range”
* (i = 0 ~ (len-1)/2 )
* len –> length of buf
*/
void printLoad(uint8_t *buf, uint8_t len)
{
if(len == 0){
Serial.println(F(“Load Successfully.”));
return;
}
else{
Serial.print(F(“Load success: “));
Serial.println(buf[0], DEC);
}
for(int i=0; i<len-1; i += 2){
Serial.print(F(“Record “));
Serial.print(buf[i+1], DEC);
Serial.print(F(“\t”));
switch(buf[i+2]){
case 0:
Serial.println(F(“Loaded”));
break;
case 0xFC:
Serial.println(F(“Record already in recognizer”));
break;
case 0xFD:
Serial.println(F(“Recognizer full”));
break;
case 0xFE:
Serial.println(F(“Record untrained”));
break;
case 0xFF:
Serial.println(F(“Value out of range”));
break;
default:
Serial.println(F(“Unknown status”));
break;
}
}
}

/**
* @brief Print “train” command return value.
* @param buf –> “train” command return value
* buf[0] –> number of records which are trained successfully.
* buf[2i+1] –> record number
* buf[2i+2] –> record train status.
* 00 –> Trained
* FE –> Train Time Out
* FF –> Value out of range”
* (i = 0 ~ len-1 )
* len –> length of buf
*/
void printTrain(uint8_t *buf, uint8_t len)
{
if(len == 0){
Serial.println(F(“Train Finish.”));
return;
}
else{
Serial.print(F(“Train success: “));
Serial.println(buf[0], DEC);
}
for(int i=0; i<len-1; i += 2){
Serial.print(F(“Record “));
Serial.print(buf[i+1], DEC);
Serial.print(F(“\t”));
switch(buf[i+2]){
case 0:
Serial.println(F(“Trained”));
break;
case 0xFE:
Serial.println(F(“Train Time Out”));
break;
case 0xFF:
Serial.println(F(“Value out of range”));
break;
default:
Serial.print(F(“Unknown status “));
Serial.println(buf[i+2], HEX);
break;
}
}
}

/**
* @brief Print “sigtrain” command return value.
* @param buf –> “sigtrain” command return value
* buf[0] –> number of records which are trained successfully.
* buf[1] –> record number
* buf[2] –> record train status.
* 00 –> Trained
* F0 –> Trained, signature truncate
* FE –> Train Time Out
* FF –> Value out of range”
* buf[3] ~ buf[len-1] –> Signature.
* len –> length of buf
*/
void printSigTrain(uint8_t *buf, uint8_t len)
{
if(len == 0){
Serial.println(F(“Train With Signature Finish.”));
return;
}
else{
Serial.print(F(“Success: “));
Serial.println(buf[0], DEC);
}
Serial.print(F(“Record “));
Serial.print(buf[1], DEC);
Serial.print(F(“\t”));
switch(buf[2]){
case 0:
Serial.println(F(“Trained”));
break;
case 0xF0:
Serial.println(F(“Trained, signature truncate”));
break;
case 0xFE:
Serial.println(F(“Train Time Out”));
break;
case 0xFF:
Serial.println(F(“Value out of range”));
break;
default:
Serial.print(F(“Unknown status “));
Serial.println(buf[2], HEX);
break;
}
Serial.print(F(“SIG: “));
Serial.write(buf+3, len-3);
Serial.println();
}

/**
* @brief Print “settings” command return value.
* @param buf –> “settings” command return value
* buf[0] –> number of records which are trained successfully.
* buf[1] –> record number
* buf[2] –> record train status.
* 00 –> Trained
* F0 –> Trained, signature truncate
* FE –> Train Time Out
* FF –> Value out of range”
* buf[3] ~ buf[len-1] –> Signature.
* len –> length of buf
*/

const unsigned int io_pw_tab[16]={
10, 15, 20, 25, 30, 35, 40, 45,
50, 75, 100, 200, 300, 400, 500, 1000
};

void printSystemSettings(uint8_t *buf, int len)
{

switch(buf[0]){
case 0:
case 3:
Serial.println(F(“Baud rate: 9600”));
break;
case 1:
Serial.println(F(“Baud rate: 2400”));
break;
case 2:
Serial.println(F(“Baud rate: 4800”));
break;
case 4:
Serial.println(F(“Baud rate: 19200”));
break;
case 5:
Serial.println(F(“Baud rate: 38400”));
break;
default:
Serial.println(F(“Baud rate: UNKONOWN”));
break;
}

switch(buf[1]){
case 0:
case 0xFF:
Serial.println(F(“Outpu IO Mode: Pulse”));
break;
case 1:
Serial.println(F(“Outpu IO Mode: Toggle”));
break;
case 2:
Serial.println(F(“Outpu IO Mode: Clear(When recognized) “));
break;
case 3:
Serial.println(F(“Outpu IO Mode: Set(When recognized)”));
break;
default:
Serial.println(F(“Output IO Mode: UNKONOWN”));
break;
}

if(buf[2] > 15){
Serial.println(F(“Pulse width: UNKONOWN”));
}
else{
Serial.print(F(“Pulse Width: “));
Serial.print(io_pw_tab[buf[2]], DEC);
Serial.println(F(“ms”));
}

if(buf[3] == 0 || buf[3] == 0xFF){
Serial.println(F(“Auto Load: disable”));
}
else{
Serial.println(F(“Auto Load: enable”));
}

switch(buf[4]){
case 0:
case 0xFF:
Serial.println(F(“Group control by external IO: disabled”));
break;
case 1:
Serial.println(F(“Group control by external IO: system group selected”));
break;
case 2:
Serial.println(F(“Group control by external IO: user group selected”));
break;
default:
Serial.println(F(“Group control by external IO: UNKNOWN STATUS”));
break;
}
}

void printHelp(void)
{
Serial.println(F(“COMMAND FORMAT EXAMPLE Comment”));
printSeperator();
// Serial.println(F(“————————————————————————————————————–“));
Serial.println(F(“train train (r0) (r1)… train 0 2 45 Train records”));
Serial.println(F(“load load (r0) (r1) … load 0 51 2 3 Load records”));
Serial.println(F(“clear clear clear remove all records in Recognizer”));
Serial.println(F(“record record / record (r0) (r1)… record / record 0 79 Check record train status”));
Serial.println(F(“vr vr vr Check recognizer status”));
Serial.println(F(“getsig getsig (r) getsig 0 Get signature of record (r)”));
Serial.println(F(“sigtrain sigtrain (r) (sig) sigtrain 0 ZERO Train one record(r) with signature(sig)”));
Serial.println(F(“settings settings settings Check current system settings”));
Serial.println(F(“help help help print this message”));
}


Voice recognition Module Controlling Arduino Code:

After you are done with the command’s training. Now the next step is to use these commands to control something.

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

/**        
  Connection
  Arduino    VoiceRecognitionModule
   2   ------->     TX
   3   ------->     RX
*/
VR myVR(2,3);    // 2:RX 3:TX, you can choose your favourite pins.

uint8_t records[7]; // save record
uint8_t buf[64];

int led = 13;



#define strong    (1)
#define weak   (4) 
#define mbde (2)
#define on (0)

#define bad (5)

/**
  @brief   Print signature, if the character is invisible, 
           print hexible value instead.
  @param   buf     --> command length
           len     --> number of parameters
*/
void printSignature(uint8_t *buf, int len)
{
  int i;
  for(i=0; i<len; i++){
    if(buf[i]>0x19 && buf[i]<0x7F){
      Serial.write(buf[i]);
    }
    else{
      Serial.print("[");
      Serial.print(buf[i], HEX);
      Serial.print("]");
    }
  }
}

/**
  @brief   Print signature, if the character is invisible, 
           print hexible value instead.
  @param   buf  -->  VR module return value when voice is recognized.
             buf[0]  -->  Group mode(FF: None Group, 0x8n: User, 0x0n:System
             buf[1]  -->  number of record which is recognized. 
             buf[2]  -->  Recognizer index(position) value of the recognized record.
             buf[3]  -->  Signature length
             buf[4]~buf[n] --> Signature
*/
void printVR(uint8_t *buf)
{
  Serial.println("VR Index\tGroup\tRecordNum\tSignature");

  Serial.print(buf[2], DEC);
  Serial.print("\t\t");

  if(buf[0] == 0xFF){
    Serial.print("NONE");
  }
  else if(buf[0]&0x80){
    Serial.print("UG ");
    Serial.print(buf[0]&(~0x80), DEC);
  }
  else{
    Serial.print("SG ");
    Serial.print(buf[0], DEC);
  }
  Serial.print("\t");

  Serial.print(buf[1], DEC);
  Serial.print("\t\t");
  if(buf[3]>0){
    printSignature(buf+4, buf[3]);
  }
  else{
    Serial.print("NONE");
  }
  Serial.println("\r\n");
}

void setup()
{
  /** initialize */
  myVR.begin(9600);
  
  Serial.begin(115200);
  Serial.println("Elechouse Voice Recognition V3 Module\r\nControl LED sample");
  
  pinMode(led, OUTPUT);

 
    
  if(myVR.clear() == 0){
    Serial.println("Recognizer cleared.");
  }else{
    Serial.println("Not find VoiceRecognitionModule.");
    Serial.println("Please check connection and restart Arduino.");
    while(1);
  }
  
  if(myVR.load((uint8_t)strong) >= 0){
    Serial.println("strong");

  }
  
  if(myVR.load((uint8_t)weak) >= 0){
    Serial.println("weak");

  }

    if(myVR.load((uint8_t)mbde) >= 0){
    Serial.println("mbde");

  }

      if(myVR.load((uint8_t)on) >= 0){
    Serial.println("on");

  }

        if(myVR.load((uint8_t)bad) >= 0){
    Serial.println("bad");

  }
}

void loop()
{
  int ret;
  ret = myVR.recognize(buf, 50);
  if(ret>0){
    switch(buf[1]){
      case weak:
// i am writng something over here 
// then you can replace with your code 
//if you want to control an led or anything else 
Serial.println("opssss you are so weak!!!!"); 
        break;
        
      case bad:
Serial.println(" no i am not bad"); 
        break;
        
        // right 

        case strong:
    
 Serial.println(" nice guess i am strong"); 
        break;

        // right 

        case on:
digitalWrite(led, HIGH); 
Serial.println(" led on pin number 13 is turned on"); 
        break;

                // rasha

        case mbde:
Serial.println("what is mbde ;)"); 
        break;
        
      default:
        Serial.println("Record function undefined");
        break;
    }
    /** voice recognized */
    printVR(buf);
  }
}


Watch Video Tutorial:

Engr Fahad

My name is Shahzada Fahad and I am an Electrical Engineer. I have been doing Job in UAE as a site engineer in an Electrical Construction Company. Currently, I am running my own YouTube channel "Electronic Clinic", and managing this Website. My Hobbies are * Watching Movies * Music * Martial Arts * Photography * Travelling * Make Sketches and so on...

2 Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

Back to top button