I am currently working on a project for college. I am trying to use 2 servos, a lcd screen, RFID scanner, an elechouse Voice Recognition Module V3(Speak Recognition, Voice Recognition Module V3 - ELECHOUSE) and a mega arduino 2560. But I am running into an issue where the voice module doesn't work with the MEGA, i've done lots of searching and found nothing. So im wondering if its even possible with the MEGA.
Please include your complete sketch, enclosed in the handy <CODE/> tag tool, and a schematic, and exactly what doesn't work (i.e what were you expecting to see happen, and what happened instead) and perhaps someone might be able to help you diagnose your problem.
/**
******************************************************************************
* @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 train (r0) (r1)... train 0 2 45 Train records
* load load (r0) (r1) ... load 0 51 2 3 Load records
* clear 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
******************************************************************************
* @section HISTORY
*
* 2013/06/13 Initial version.
*/
#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(19200);
/** 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, ¶Addr);
/** 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, ¶Addr);
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, ¶Addr);
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, ¶Addr);
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, ¶Addr);
records[0] = atoi((char *)paraAddr);
if(records[0] == 0 && *paraAddr != '0'){
return -1;
}
findPara(len, 3, ¶Addr);
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, ¶Addr);
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[8*i+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"));
}
basically the problem is when i plug the rxd and txd into pins 2 and 3 (which is the same as the regular arduino which when I tested that it worked on the regular arduino). When I run the code and type "train 0" to train a key word, it waits for about 5 seconds then go to 'train timeout'. So I don't know if its because I have it hooked up wrong or if the module just doesn't work together with the MEGA
You were requested to post the schematics... is Rx connected to Rx, Tx to Tx? If they are, it's wrong,
Why are you using SoftwareSerial with a board that has 3 extra hardware serial ports?
And perhaps this text from the SoftwareSerial library reference page is germane to your problem:
SoftwareSerial library has the following known limitations:
- It cannot transmit and receive data at the same time.
- If using multiple software serial ports, only one can receive data at a time.
- Not all pins on the Mega and Mega 2560 boards support change interrupts, so only the following can be used for RX: 10, 11, 12, 13, 14, 15, 50, 51, 52, 53, A8 (62), A9 (63), A10 (64), A11 (65), A12 (66), A13 (67), A14 (68), A15 (69). Not all pins on the Leonardo and Micro boards support change interrupts, so only the following can be used for RX: 8, 9, 10, 11, 14 (MISO), 15 (SCK), 16 (MOSI).
1 Like
Yes they are connected to the correct ones. That was the first thing I checked as it should be everyones first thing to check.
So, I tried to change TXD to pin 11 and RXD to pin 10 and changed this line to "VR myVR(10,11); ", and I still get the same error, "Usage:
COMMAND FORMAT EXAMPLE Comment
train train (r0) (r1)... train 0 2 45 Train records
load load (r0) (r1) ... load 0 51 2 3 Load records
clear 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
help help help print this message
train 0
Train Timeout.
-------------------------------------------"
aka Train 0 then Train Timeout.
Software Serial is for when you don't have a serial port available. It uses software to "fake" a serial port. We often need it because the UNO only has one serial port and people want to use it for the serial monitor and need a second one for their project.
You are using the Mega. It has 4 serial ports. You are using one of them for the Serial Monitor. You still have 3 hardware serial ports available.
So why are you using Software Serial at all? That's ridiculous. Get rid of Software Serial entirely and just use Serial1 or Serial2 or Serial3.
I'm new to using an arduino as I just bought it and am still trying to figure things out so this is all new information. Which ports are Serial1 or Serial2 or Serial3?
Then you should take some time to learn the basics before you jump off into something way over your head and look foolish.
Look up the page for the Mega. It talks all about it's various serial ports and where they are. It talks about a lot of things that you would do well to at least read once before you get started copying code that you don't understand and that was written for another board.
1 Like
How much code would I have to change in order to get this program function?
One step at a time. Start by fixing the serial port.
I've done the research for that part, I am going to put Rx in 19 and Tx in 18 for Serial1. So now I just need to update the code for these changes, which is the main problem.
Yes. Just swap the SoftwareSerial instance for Serial1. Post the new code when you're done and talk about the new symptoms.
clarifying question, i wanna keep using the serial monitor for right now, I assume I don't change every 'serial' lines to serial1. Is that correct?
What?
No, you are replacing the SoftwareSerial instance with Serial1. Not Serial.
What is your experience with Arduino and coding in general? I'm starting to get the feeling that you may be so far over your head that it will be very hard to help you without you going back and spending some time on the basics.
In a nutshell, you change the library to use HardwareSerial rather than SoftwareSerial. It's probably no more than 5 minutes work.
The VR class is derived from SoftwareSerial. Get rid of that derivation.
Add a HardwareSerial class variable, call it serial.
Change the VR constructor to take a pointer to a HardwareSerial and assign the pointer to the serial class variable, like so:
VR::VR(HardwareSerial *_serial)
{
instance = this;
serial = _serial;
}
which you would use thusly:
VR myvr(&Serial1);
Remove the SoftwareSerial's begin call from the VR constructor. Add a begin method to the VR class that looks something like this:
void VR::begin(long _speed) {
serial->begin(_speed);
}
Anywhere in the library code where there's a call to available, read or write, change them to serial->available, serial->read or serial->write. That will likely be all there is to it.
You could extend the library to work with both SoftwareSerial and HardwareSerial but for your use case, why bother? If it really bothers you, make the changes in a copy of the library and call it HardwareSerialVR.
"The VR class is derived from SoftwareSerial. Get rid of that derivation."
I'm not sure what this means if i'm being honest, what exactly should I do.
Hopefully not. The library probably takes Stream from which they both derive. If it doesn't then it should.
Can you give us a link to the library you're using?