def recognize_ibm(self, audio_data, username, password, language="en-US", show_all=False,
url="https://stream.watsonplatform.net/speech-to-text/api"):
"""
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the IBM Speech to Text API.
The IBM Speech to Text username and password are specified by ``username`` and ``password``, respectively. Unfortunately, these are not available without `signing up for an account <https://console.ng.bluemix.net/registration/>`__. Once logged into the Bluemix console, follow the instructions for `creating an IBM Watson service instance <https://www.ibm.com/watson/developercloud/doc/getting_started/gs-credentials.shtml>`__, where the Watson service is "Speech To Text". IBM Speech to Text usernames are strings of the form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX, while passwords are mixed-case alphanumeric strings.
The recognition language is determined by ``language``, an RFC5646 language tag with a dialect like ``"en-US"`` (US English) or ``"zh-CN"`` (Mandarin Chinese), defaulting to US English. The supported language values are listed under the ``model`` parameter of the `audio recognition API documentation <https://www.ibm.com/watson/developercloud/speech-to-text/api/v1/#sessionless_methods>`__, in the form ``LANGUAGE_BroadbandModel``, where ``LANGUAGE`` is the language value.
Returns the most likely transcription if ``show_all`` is false (the default). Otherwise, returns the `raw API response <https://www.ibm.com/watson/developercloud/speech-to-text/api/v1/#sessionless_methods>`__ as a JSON dictionary.
Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if the speech recognition operation failed, if the key isn't valid, or if there is no internet connection.
"""
assert isinstance(audio_data, sr.AudioData), "Data must be audio data"
assert isinstance(username, str), "``username`` must be a string"
assert isinstance(password, str), "``password`` must be a string"
flac_data = audio_data.get_flac_data(
convert_rate=None if audio_data.sample_rate >= 16000 else 16000, # audio samples should be at least 16 kHz
convert_width=None if audio_data.sample_width >= 2 else 2 # audio samples should be at least 16-bit
)
url = "{}/v1/recognize?{}".format(url, urlencode({
"profanity_filter": "false",
"continuous": "true",
"model": "{}_BroadbandModel".format(language),
}))
request = Request(url, data=flac_data, headers={
"Content-Type": "audio/x-flac",
"X-Watson-Learning-Opt-Out": "true", # prevent requests from being logged, for improved privacy
})
authorization_value = base64.standard_b64encode("{}:{}".format(username, password).encode("utf-8")).decode(
"utf-8")
request.add_header("Authorization", "Basic {}".format(authorization_value))
try:
response = urlopen(request, timeout=self.operation_timeout)
except HTTPError as e:
raise sr.RequestError("recognition request failed: {}".format(e.reason))
except URLError as e:
raise sr.RequestError("recognition connection failed: {}".format(e.reason))
response_text = response.read().decode("utf-8")
result = json.loads(response_text)
# return results
if show_all: return result
if "results" not in result or len(result["results"]) < 1 or "alternatives" not in result["results"][0]:
raise sr.UnknownValueError()
transcription = []
for utterance in result["results"]:
if "alternatives" not in utterance: raise sr.UnknownValueError()
for hypothesis in utterance["alternatives"]:
if "transcript" in hypothesis:
transcription.append(hypothesis["transcript"])
return "\n".join(transcription)
def google_post(speech_filepath):
try:
# for testing purposes, we're just using the default API key
# to use another API key, use `r.recognize_google(audio, key="GOOGLE_SPEECH_RECOGNITION_API_KEY")`
# instead of `r.recognize_google(audio)`
actual_result = ''
with open(os.path.splitext(speech_filepath)[0] + '.json') as json_data:
actual_result = json.load(json_data)
if not isinstance(actual_result, dict) or len(actual_result.get("alternative", [])) == 0: raise sr.UnknownValueError()
if "confidence" in actual_result["alternative"]:
# return alternative with highest confidence score
best_hypothesis = max(actual_result["alternative"], key=lambda alternative: alternative["confidence"])
else:
# when there is no confidence available, we arbitrarily choose the first hypothesis.
best_hypothesis = actual_result["alternative"][0]
if "transcript" not in best_hypothesis: raise sr.UnknownValueError()
transcription = best_hypothesis["transcript"]
print("Google Speech Recognition transcription is: " + transcription)
return transcription
except sr.UnknownValueError:
print("Google Speech Recognition could not understand audio")
except sr.RequestError as e:
print("Could not request results from Google Speech Recognition service; {0}".format(e))
asr_could_not_be_reached = True
def __init__(self):
self.__logger = Logger()
self._request_exceptions = [type(item) for item in [requests.ConnectionError(), requests.HTTPError(),
requests.TooManyRedirects(), requests.Timeout(),
requests.TooManyRedirects(),
requests.RequestException(), requests.ConnectTimeout(),
requests.ReadTimeout()]]
self._system_errors = [type(item) for item in [KeyError(), AttributeError(), IndexError(),
ZeroDivisionError(), SystemError(), ValueError(),
AssertionError()]]
self._file_errors = [type(item) for item in [FileExistsError(), FileNotFoundError()]]
self._database_errors = [type(item) for item in [sqlite3.Error(), sqlite3.DataError(),
sqlite3.ProgrammingError(), sqlite3.DatabaseError(),
sqlite3.NotSupportedError(), sqlite3.IntegrityError(),
sqlite3.InterfaceError(), sqlite3.InternalError(),
sqlite3.OperationalError()]]
self._speech_recognizer_errors = [type(item) for item in
[sr.RequestError(), sr.UnknownValueError(), sr.WaitTimeoutError(),
sr.RequestError()]]
self.__logger.info('ExceptionsHandler was successfully initialized.', __name__)
def test_listen_raises_value_error(self):
with patch.object(self.listener, 'transcribe') as transcribe:
transcribe.side_effect = sr.UnknownValueError()
with self.assertRaises(ValueError) as context:
self.listener.listen()
self.assertIn('Could not translate speech', str(context.exception))
def recognize_mycroft(self,
audio,
key=None,
language=None,
show_all=False):
if len(self.transcriptions) > 0:
return self.transcriptions.pop(0)
else:
raise speech_recognition.UnknownValueError()
def recognize_amazon(audio_data,
bot_name,
bot_alias,
user_id,
content_type="audio/l16; rate=16000; channels=1",
access_key_id=None,
secret_access_key=None,
region=None):
"""
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance).
If access_key_id or secret_access_key is not set it will go through the list in the link below
http://boto3.readthedocs.io/en/latest/guide/configuration.html#configuring-credentials
Author: Patrick Artounian (https://github.com/partounian)
Source: https://github.com/Uberi/speech_recognition/pull/331
"""
assert isinstance(audio_data, sr.AudioData), "Data must be audio data"
assert isinstance(bot_name, str), "``bot_name`` must be a string"
assert isinstance(bot_alias, str), "``bot_alias`` must be a string"
assert isinstance(user_id, str), "``user_id`` must be a string"
assert isinstance(content_type, str), "``content_type`` must be a string"
assert access_key_id is None or isinstance(
access_key_id, str), "``access_key_id`` must be a string"
assert secret_access_key is None or isinstance(
secret_access_key, str), "``secret_access_key`` must be a string"
assert region is None or isinstance(region,
str), "``region`` must be a string"
try:
import boto3
except ImportError:
raise sr.RequestError(
"missing boto3 module: ensure that boto3 is set up correctly.")
client = boto3.client('lex-runtime',
aws_access_key_id=access_key_id,
aws_secret_access_key=secret_access_key,
region_name=region)
raw_data = audio_data.get_raw_data(convert_rate=16000, convert_width=2)
accept = "text/plain; charset=utf-8"
response = client.post_content(botName=bot_name,
botAlias=bot_alias,
userId=user_id,
contentType=content_type,
accept=accept,
inputStream=raw_data)
if not response["inputTranscript"]:
raise sr.UnknownValueError()
return response["inputTranscript"], response
def speechToText(sound):
try:
r = sr.Recognizer()
with sound as source:
audio = r.record(source)
text = r.recognize_google(audio)
return text
except sr.UnknownValueError:
raise sr.UnknownValueError("Sound file clarity too low, try again.")
except FileNotFoundError:
raise FileNotFoundError("Check your file source and try again!")
def command():
c = sr.Recognizer() # Nhận giọng nói
with sr.Microphone() as source:
c.pause_threshold = 2 # Dừng 2s trước khi nghe lệnh mới
audio = c.listen(source) # Lắng nghe từ microphone
try:
query = c.recognize_google(audio, language='en')
print("Tony Kien: " + query)
except sr.UnknownValueError(): # Nếu nó không nghe được
print("Please repeat or typing the command")
query = str(input('Your Order Is: '))
return query
def test_could_not_parse_text(self):
with mock.patch('speech_recognition.Microphone') as mocked_mic:
mocked_mic.return_value.__enter__ = lambda x: time.sleep(.5)
rel_path = os.path.join(os.getcwd(), "audio-files/harvard.wav")
harvard = sr.AudioFile(rel_path)
os.system = mock.MagicMock()
l = Listener()
with harvard as source:
audio = l.recognizer.record(source)
l.recognizer.listen = mock.MagicMock(return_value=audio)
l.transcribe = mock.Mock(side_effect=sr.UnknownValueError("test"))
s = Timer(1.0, l.stop)
s.start()
l.listen()
assert os.system.called
def transcribe(speech_filepath, asr_system, settings, save_transcription=True):
'''
Returns:
- transcription: string corresponding the transcription obtained from the ASR API or existing transcription file.
- transcription_skipped: Boolean indicating if the speech file was sent to the ASR API.
'''
transcription_json = ''
transcription_filepath_base = '.'.join(speech_filepath.split('.')[:-1]) + '_' + asr_system
transcription_filepath_text = transcription_filepath_base + '.txt'
transcription_filepath_json = transcription_filepath_base + '.json'
# If there already exists a transcription file, we may skip it depending on the user settings.
if os.path.isfile(transcription_filepath_text):
existing_transcription = codecs.open(transcription_filepath_text, 'r', settings.get('general','predicted_transcription_encoding')).read()
is_transcription_file_empty = len(existing_transcription.strip()) == 0
if not is_transcription_file_empty and not settings.getboolean('general','overwrite_non_empty_transcriptions'):
print('Skipped speech file {0} because the file {1} already exists and is not empty.'.format(speech_filepath,transcription_filepath_text))
print('Change the setting `overwrite_non_empty_transcriptions` to True if you want to overwrite existing transcriptions')
transcription_skipped = True
return existing_transcription, transcription_skipped
if is_transcription_file_empty and not settings.getboolean('general','overwrite_empty_transcriptions'):
print('Skipped speech file {0} because the file {1} already exists and is empty.'.format(speech_filepath,transcription_filepath_text))
print('Change the setting `overwrite_empty_transcriptions` to True if you want to overwrite existing transcriptions')
transcription_skipped = True
return existing_transcription, transcription_skipped
# use the audio file as the audio source
r = sr.Recognizer()
with sr.AudioFile(speech_filepath) as source:
audio = r.record(source) # read the entire audio file
transcription = ''
asr_could_not_be_reached = False
asr_timestamp_started = time.time()
speech_language = settings.get('general','speech_language')
if asr_system == 'google':
# recognize speech using Google Speech Recognition
try:
# for testing purposes, we're just using the default API key
# to use another API key, use `r.recognize_google(audio, key="GOOGLE_SPEECH_RECOGNITION_API_KEY")`
# instead of `r.recognize_google(audio)`
response = r.recognize_google(audio, show_all=True, language=speech_language)
transcription_json = response
actual_result = response
if not isinstance(actual_result, dict) or len(actual_result.get("alternative", [])) == 0: raise sr.UnknownValueError()
if "confidence" in actual_result["alternative"]:
# return alternative with highest confidence score
best_hypothesis = max(actual_result["alternative"], key=lambda alternative: alternative["confidence"])
else:
# when there is no confidence available, we arbitrarily choose the first hypothesis.
best_hypothesis = actual_result["alternative"][0]
if "transcript" not in best_hypothesis: raise sr.UnknownValueError()
transcription = best_hypothesis["transcript"]
print("Google Speech Recognition transcription is: " + transcription)
except sr.UnknownValueError:
print("Google Speech Recognition could not understand audio")
except sr.RequestError as e:
print("Could not request results from Google Speech Recognition service; {0}".format(e))
asr_could_not_be_reached = True
elif asr_system == 'google_post':
transcription = google_post(speech_filepath)
elif asr_system == 'googlecloud':
# recognize speech using Google Cloud Speech
GOOGLE_CLOUD_SPEECH_CREDENTIALS_filepath = settings.get('credentials','google_cloud_speech_credentials_filepath')
GOOGLE_CLOUD_SPEECH_CREDENTIALS = codecs.open(GOOGLE_CLOUD_SPEECH_CREDENTIALS_filepath, 'r', 'UTF-8').read()
try:
response = r.recognize_google_cloud(audio, credentials_json=GOOGLE_CLOUD_SPEECH_CREDENTIALS, show_all=True, language=speech_language)
transcription_json = response
if "results" not in response or len(response["results"]) == 0: raise sr.UnknownValueError()
transcript = ""
for result in response["results"]:
transcript += result["alternatives"][0]["transcript"].strip() + " "
transcription = transcript
except sr.UnknownValueError:
print("Google Cloud Speech could not understand audio")
except sr.RequestError as e:
print("Could not request results from Google Cloud Speech service; {0}".format(e))
asr_could_not_be_reached = True
# recognize speech using Wit.ai
elif asr_system == 'wit':
WIT_AI_KEY = settings.get('credentials','wit_ai_key')
print("Calling the Wit.ai API")
try:
response = r.recognize_wit(audio, key=WIT_AI_KEY, show_all=True)
transcription_json = response
if "_text" not in response or response["_text"] is None: raise sr.UnknownValueError()
transcription = response["_text"]
except sr.UnknownValueError:
print("Wit.ai could not understand audio")
except sr.RequestError as e:
print("Could not request results from Wit.ai service; {0}".format(e))
asr_could_not_be_reached = True
# recognize speech using Microsoft Bing Voice Recognition
elif asr_system == 'microsoft':
BING_KEY = settings.get('credentials','bing_key')
print('Calling the Microsoft Bing Voice Recognition API')
try:
response = r.recognize_bing(audio, key=BING_KEY, show_all=True, language=speech_language)
transcription_json = response
if "RecognitionStatus" not in response or response["RecognitionStatus"] != "Success" or "DisplayText" not in response:
raise sr.UnknownValueError()
transcription = response["DisplayText"]
except sr.UnknownValueError:
print("Microsoft Bing Voice Recognition could not understand audio")
except sr.RequestError as e:
print("Could not request results from Microsoft Bing Voice Recognition service; {0}".format(e))
asr_could_not_be_reached = True
elif asr_system == 'houndify':
# recognize speech using Houndify
HOUNDIFY_CLIENT_ID = settings.get('credentials','houndify_client_id')
HOUNDIFY_CLIENT_KEY = settings.get('credentials','houndify_client_key')
print("Calling the Houndify API")
try:
response = r.recognize_houndify(audio, client_id=HOUNDIFY_CLIENT_ID, client_key=HOUNDIFY_CLIENT_KEY, show_all=True)
transcription_json = response
if "Disambiguation" not in response or response["Disambiguation"] is None:
raise sr.UnknownValueError()
transcription = response['Disambiguation']['ChoiceData'][0]['Transcription']
except sr.UnknownValueError:
print("Houndify could not understand audio")
except sr.RequestError as e:
print("Could not request results from Houndify service; {0}".format(e))
asr_could_not_be_reached = True
# recognize speech using IBM Speech to Text
elif asr_system == 'ibm':
IBM_USERNAME = settings.get('credentials','ibm_username')
IBM_PASSWORD = settings.get('credentials','ibm_password')
try:
response = r.recognize_ibm(audio, username=IBM_USERNAME, password=IBM_PASSWORD, show_all=True, language=speech_language)
transcription_json = response
if "results" not in response or len(response["results"]) < 1 or "alternatives" not in response["results"][0]:
raise sr.UnknownValueError()
transcription = []
for utterance in response["results"]:
if "alternatives" not in utterance: raise sr.UnknownValueError()
for hypothesis in utterance["alternatives"]:
if "transcript" in hypothesis:
transcription.append(hypothesis["transcript"])
transcription = "\n".join(transcription)
transcription = transcription.strip()
except sr.UnknownValueError:
print("IBM Speech to Text could not understand audio")
except sr.RequestError as e:
print("Could not request results from IBM Speech to Text service; {0}".format(e))
asr_could_not_be_reached = True
# custom IBM to use already downloaded
elif asr_system == 'ibm_post':
IBM_USERNAME = settings.get('credentials','ibm_username')
IBM_PASSWORD = settings.get('credentials','ibm_password')
try:
#print('speech filepath', speech_filepath, os.path.splitext(speech_filepath)[0] + '.json')
transcription_json = ''
with open(os.path.splitext(speech_filepath)[0] + '.json') as json_data:
transcription_json = json.load(json_data)
response = transcription_json
if "results" not in response or len(response["results"]) < 1 or "alternatives" not in response["results"][0]:
raise sr.UnknownValueError()
transcription = []
for utterance in response["results"]:
if "alternatives" not in utterance: raise sr.UnknownValueError()
for hypothesis in utterance["alternatives"]:
if "transcript" in hypothesis:
transcription.append(hypothesis["transcript"])
transcription = "\n".join(transcription)
transcription = transcription.strip()
transcription = re.sub('%HESITATION', '', transcription)
except sr.UnknownValueError:
print("IBM Speech to Text could not understand audio")
except sr.RequestError as e:
print("Could not request results from IBM Speech to Text service; {0}".format(e))
asr_could_not_be_reached = True
elif asr_system == 'speechmatics':
# recognize speech using Speechmatics Speech Recognition
speechmatics_id = settings.get('credentials','speechmatics_id')
speechmatics_token = settings.get('credentials','speechmatics_token')
print('speech_filepath: {0}'.format(speech_filepath))
transcription, transcription_json = asr_speechmatics.transcribe_speechmatics(speechmatics_id,speechmatics_token,speech_filepath,speech_language)
try:
print('Speechmatics transcription is: {0}'.format(transcription))
except:
print('Speechmatics encountered some issue')
asr_could_not_be_reached = True
elif asr_system == 'amazon':
try:
bot_name = settings.get('credentials','amazon_bot_name')
bot_alias = settings.get('credentials','amazon_bot_alias')
user_id = settings.get('credentials','amazon_user_id')
transcription,transcription_json = recognize_amazon(audio, bot_name, bot_alias, user_id,
content_type="audio/l16; rate=16000; channels=1", access_key_id=settings.get('credentials','amazon_access_key_id'),
secret_access_key=settings.get('credentials','amazon_secret_access_key'), region=settings.get('credentials','amazon_region'))
except sr.UnknownValueError:
print("Amazon not process the speech transcription request")
else: raise ValueError("Invalid asr_system. asr_system = {0}".format(asr_system))
asr_timestamp_ended = time.time()
asr_time_elapsed = asr_timestamp_ended - asr_timestamp_started
print('asr_time_elapsed: {0:.3f} seconds'.format(asr_time_elapsed))
#time.sleep(2) # Delay in seconds
#if len(transcription) == 0 and asr_could_not_be_reached: return transcription
if save_transcription:
#print('Transcription saved in {0} and {1}'.format(transcription_filepath_text,transcription_filepath_json))
codecs.open(transcription_filepath_text,'w', settings.get('general','predicted_transcription_encoding')).write(transcription)
print('transcription: {0}'.format(transcription))
results = {}
results['transcription'] = transcription
results['transcription_json'] = transcription_json
results['asr_time_elapsed'] = asr_time_elapsed
results['asr_timestamp_ended'] = asr_timestamp_ended
results['asr_timestamp_started'] = asr_timestamp_started
json.dump(results, codecs.open(transcription_filepath_json, 'w', settings.get('general','predicted_transcription_encoding')), indent = 4, sort_keys=True)
transcription_skipped = False
return transcription, transcription_skipped
import speech_recognition
# Build recognizer object
recognizer = speech_recognition.Recognizer()
while True:
try:
# Set up input and declare mic
with speech_recognition.Microphone() as mic:
recognizer.adjust_for_ambient_noise(mic, duration = .2)
#define audio and input
audio = recognizer.listen(mic)
#convert audio to text
text = recognizer.recognize_google(audio)
text = text.lower()
print(f"Recognized {text}")
except speech_recognition.UnknownValueError():
# If audio cant be picked up, try again
recognizer = speech_recognition.Recognizer()
continue
def alarm(source):
conn = sqlite3.connect('/home/pi/Oracle/Oracle')
cursor = conn.cursor()
speak("Hour is sir ?")
with source as source:
# os.system('play -nq -t alsa synth {} sine {}'.format(0.15, 500)) # 1 = duration, 440 = frequency -> this sounds a beep
audio = r.listen(source)
try:
hour = r.recognize_google(audio)
speak("And minute is ?")
# os.system('play -nq -t alsa synth {} sine {}'.format(0.15, 500)) # 1 = duration, 440 = frequency -> this sounds a beep
audio = r.listen(source)
minute = r.recognize_google(audio)
hour = int(hour)
minute = int(minute)
speak(f"You asked me to set an alarm for {hour} {minute} sir")
cursor.execute("INSERT INTO Alarms (hour, minute) VALUES (?, ?)",
(hour, minute))
conn.commit()
except ValueError or sr.UnknownValueError or speech_recognition.UnknownValueError or sr.UnknownValueError(
):
speak("There was an error sir, i am gonna ask you to repeat it")
alarm()
except sr.RequestError as e:
print(
"Could not request results from Google Speech Recognition service; {0}"
.format(e))
alarm()
conn.close()
def recognize_ibm(audio_data,
username,
password,
language="en-US",
show_all=False):
assert isinstance(audio_data, sr.AudioData), "Data must be audio data"
assert isinstance(username, str), "``username`` must be a string"
assert isinstance(password, str), "``password`` must be a string"
flac_data = audio_data.get_flac_data(
convert_rate=None if audio_data.sample_rate >= 16000 else
16000, # audio samples should be at least 16 kHz
convert_width=None if audio_data.sample_width >= 2 else
2 # audio samples should be at least 16-bit
)
url = "https://stream.watsonplatform.net/speech-to-text/api/v1/recognize?{}".format(
urlencode({
"profanity_filter": "false",
"model": "{}_BroadbandModel".format(language),
"inactivity_timeout":
-1, # don't stop recognizing when the audio stream activity stops
"timestamps": "true"
}))
request = Request(
url,
data=flac_data,
headers={
"Content-Type": "audio/x-flac",
"X-Watson-Learning-Opt-Out":
"true", # prevent requests from being logged, for improved privacy
})
authorization_value = base64.standard_b64encode("{}:{}".format(
username, password).encode("utf-8")).decode("utf-8")
request.add_header("Authorization", "Basic {}".format(authorization_value))
try:
response = urlopen(request, timeout=None)
except HTTPError as e:
raise sr.RequestError("recognition request failed: {}".format(
e.reason))
except URLError as e:
raise sr.RequestError("recognition connection failed: {}".format(
e.reason))
response_text = response.read().decode("utf-8")
result = json.loads(response_text)
# return results
if show_all:
return result
if "results" not in result or len(
result["results"]
) < 1 or "alternatives" not in result["results"][0]:
raise sr.UnknownValueError()
transcription = []
for utterance in result["results"]:
if "alternatives" not in utterance:
raise sr.UnknownValueError()
for hypothesis in utterance["alternatives"]:
if "transcript" in hypothesis:
transcription.append(hypothesis["transcript"])
return "\n".join(transcription)
# Porta que custumo utilizar: /dev/ttyACM0 ou /dev/ttyACM1
import speech_recognition as sr
from pyfirmata import Arduino, util
from assintent import get_microphone, p2s
from time import sleep
placa = Arduino("/dev/ttyACM0")
led = placa.digital[4]
while True:
voz = get_microphone().lower()
try:
if voz == "ligar led":
p2s("ligando led...")
led.write(1)
if voz == "desligar led":
p2s("desligando led... ")
led.write(0)
except sr.UnknownValueError():
p2s("Não entendi mestre?")
def recognize():
# set a threshold to triggering noise relative to ambient noise
with m as source:
r.adjust_for_ambient_noise(source)
# initial console output
print("[VOICE] Set minimum energy threshold to", r.energy_threshold)
print("[VOICE] Say some things!")
# run until broken by keypress or interrupt
while True:
# listen for ESC or Q key and break loop if pressed
key = cv2.waitKey(1)
if key == 27 or key == ord('q') or key == ord('Q'):
break
# listen for input on microphone, set a limit to quickly get on to the
# evaluation after input (no command takes longer than two seconds)
with m as source:
# add Snowboy config to listen function for hotword detection
audio = r.listen(source, phrase_time_limit=2)
try:
# recognize speech using Sphinx to interpret locally
# (add keyword_entries=keywords argument for Sphinx)
# using Google's engine for now because of the much higher accuracy
value = r.recognize_google(audio).lower()
# output recognized text -> subset of the keywords (when using
# Sphinx)
print("[VOICE] [DEBUG] You said:", value)
# distinguish commands ("stop" used first to make rover stop
# when in doubt) and call corresponding functions
if "stop" in value:
stop_driving_recognized()
elif "start" in value:
drive_forward_recognized()
elif "move" in value:
if "left" in value:
turn_left_recognized()
elif "right" in value:
turn_right_recognized()
else:
raise sr.UnknownValueError("[VOICE] [ERROR] " +
"Direction not recognized.")
else:
raise sr.UnknownValueError("[VOICE] [ERROR] " +
"Input not recognized.")
# raised when the input was not empty but could not be recognized
except sr.UnknownValueError:
print("[VOICE] [ERROR] Unknown Value!")
except sr.RequestError as e:
print("[VOICE] [ERROR] Speech Recognition Engine - " +
"Request not fulfilled; {0}".format(e))
except KeyboardInterrupt:
break
