def handle_speak(event):
utterance = event.data['utterance']
expect_response = event.data.get('expect_response', False)
# This is a bit of a hack for Picroft. The analog audio on a Pi blocks
# for 30 seconds fairly often, so we don't want to break on periods
# (decreasing the chance of encountering the block). But we will
# keep the split for non-Picroft installs since it give user feedback
# faster on longer phrases.
#
# TODO: Remove or make an option? This is really a hack, anyway,
# so we likely will want to get rid of this when not running on Mimic
if not config.get('enclosure', {}).get('platform') == "picroft":
chunks = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s',
utterance)
for chunk in chunks:
try:
mute_and_speak(chunk)
except:
logger.error('Error in mute_and_speak', exc_info=True)
else:
mute_and_speak(utterance)
if expect_response:
create_signal('buttonPress')
def on_message(self, message):
utterance = json.dumps(message)
print("*****Utterance : ", utterance)
if utterance:
if utterance == '"mic_on"':
create_signal('startListening')
else:
if "|SILENT" in utterance:
utterance = utterance.split("|")
utterance = utterance[0]
data = {
"lang": lang,
"session": "",
"utterances": [utterance],
"client": "WebChat"
}
ws.emit(Message('chat_response', data))
ws.emit(Message('recognizer_loop:utterance', data))
else:
data = {
"lang": lang,
"session": "",
"utterances": [utterance]
}
ws.emit(Message('recognizer_loop:utterance', data))
t = Thread(target=self.newThread)
t.start()
def execute(self, sentence, ident=None):
"""
Convert sentence to speech, preprocessing out unsupported ssml
The method caches results if possible using the hash of the
sentence.
Args:
sentence: Sentence to be spoken
ident: Id reference to current interaction
"""
sentence = self.validate_ssml(sentence)
create_signal("isSpeaking")
if self.phonetic_spelling:
for word in re.findall(r"[\w']+", sentence):
if word.lower() in self.spellings:
sentence = sentence.replace(word,
self.spellings[word.lower()])
key = str(hashlib.md5(sentence.encode('utf-8', 'ignore')).hexdigest())
wav_file = os.path.join(mycroft.util.get_cache_directory("tts"),
key + '.' + self.audio_ext)
if os.path.exists(wav_file):
LOG.debug("TTS cache hit")
phonemes = self.load_phonemes(key)
else:
wav_file, phonemes = self.get_tts(sentence, wav_file)
if phonemes:
self.save_phonemes(key, phonemes)
vis = self.visime(phonemes)
self.queue.put((self.audio_ext, wav_file, vis, ident))
def execute(self,
sentence,
ident=None,
listen=False,
play_error_sound=False):
"""Convert sentence to speech, preprocessing out unsupported ssml
The method caches results if possible using the hash of the
sentence.
Arguments:
sentence: (str) Sentence to be spoken
ident: (str) Id reference to current interaction
listen: (bool) True if listen should be triggered at the end
of the utterance.
play_error_sound: This utterance is an error. Depending on
configuration, mycroft could play a sound
instead
"""
sentence = self.validate_ssml(sentence)
create_signal("isSpeaking")
if play_error_sound:
self.queue.put(('wav', self.audio_file_error, None, ident, None))
else:
try:
self._execute(sentence, ident, listen)
except Exception:
# If an error occurs end the audio sequence with an empty entry
self.queue.put(EMPTY_PLAYBACK_QUEUE_TUPLE)
# Re-raise to allow the Exception to be handled externally.
raise
def execute(self, sentence, ident=None):
"""
Convert sentence to speech.
The method caches results if possible using the hash of the
sentence.
Args:
sentence: Sentence to be spoken
ident: Id reference to current interaction
"""
create_signal("isSpeaking")
if self.phonetic_spelling:
for word in re.findall(r"[\w']+", sentence):
if word in self.spellings:
sentence = sentence.replace(word, self.spellings[word])
key = str(hashlib.md5(sentence.encode('utf-8', 'ignore')).hexdigest())
wav_file = os.path.join(mycroft.util.get_cache_directory("tts"),
key + '.' + self.type)
if os.path.exists(wav_file):
LOG.debug("TTS cache hit")
phonemes = self.load_phonemes(key)
else:
wav_file, phonemes = self.get_tts(sentence, wav_file)
if phonemes:
self.save_phonemes(key, phonemes)
self.queue.put((self.type, wav_file, self.visime(phonemes), ident))
def handle_speak(event):
utterance = event.data['utterance']
expect_response = event.data.get('expect_response', False)
# This is a bit of a hack for Picroft. The analog audio on a Pi blocks
# for 30 seconds fairly often, so we don't want to break on periods
# (decreasing the chance of encountering the block). But we will
# keep the split for non-Picroft installs since it give user feedback
# faster on longer phrases.
#
# TODO: Remove or make an option? This is really a hack, anyway,
# so we likely will want to get rid of this when not running on Mimic
if not config.get('enclosure', {}).get('platform') == "picroft":
chunks = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s',
utterance)
for chunk in chunks:
try:
mute_and_speak(chunk)
except:
logger.error('Error in mute_and_speak', exc_info=True)
else:
mute_and_speak(utterance)
if expect_response:
create_signal('buttonPress')
def handle_start_skipping(self, message):
self.speak("Should I start skipping wake words?", True)
self.enable_intent('ConfirmYes')
self.enable_intent('ConfirmNo')
create_signal('StartSkippingWW')
create_signal('WaitingToConfirm')
def process(self, data):
self.client.emit(Message(data))
if "mycroft.stop" in data:
create_signal('buttonPress')
self.client.emit(Message("mycroft.stop"))
if "volume.up" in data:
self.client.emit(
Message("IncreaseVolumeIntent", metadata={'play_sound': True}))
if "volume.down" in data:
self.client.emit(
Message("DecreaseVolumeIntent", metadata={'play_sound': True}))
if "system.test.begin" in data:
self.client.emit(Message('recognizer_loop:sleep'))
if "system.test.end" in data:
self.client.emit(Message('recognizer_loop:wake_up'))
if "mic.test" in data:
mixer = Mixer()
prev_vol = mixer.getvolume()[0]
mixer.setvolume(35)
self.client.emit(
Message("speak",
metadata={'utterance': "I am testing one two three"}))
time.sleep(0.5) # Prevents recording the loud button press
record("/tmp/test.wav", 3.0)
mixer.setvolume(prev_vol)
play_wav("/tmp/test.wav")
time.sleep(3.5) # Pause between tests so it's not so fast
# Test audio muting on arduino
subprocess.call('speaker-test -P 10 -l 0 -s 1', shell=True)
if "unit.shutdown" in data:
self.client.emit(
Message("enclosure.eyes.timedspin", metadata={'length':
12000}))
self.client.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl poweroff -i', shell=True)
if "unit.reboot" in data:
self.client.emit(Message("enclosure.eyes.spin"))
self.client.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
if "unit.setwifi" in data:
self.client.emit(Message("mycroft.wifi.start"))
if "unit.factory-reset" in data:
subprocess.call('rm ~/.mycroft/identity/identity.json', shell=True)
self.client.emit(Message("enclosure.eyes.spin"))
self.client.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
def test_wait_while_speaking(self):
# Check that test terminates
create_signal('isSpeaking')
Thread(target=wait_while_speaking_thread).start()
sleep(2)
self.assertFalse(done_waiting)
check_for_signal('isSpeaking')
sleep(2)
self.assertTrue(done_waiting)
def test_wait_while_speaking(self):
# Check that test terminates
create_signal('isSpeaking')
Thread(target=wait_while_speaking_thread).start()
sleep(2)
self.assertFalse(done_waiting)
check_for_signal('isSpeaking')
sleep(2)
self.assertTrue(done_waiting)
def test_check_signal(self):
if exists('/tmp/mycroft'):
rmtree('/tmp/mycroft')
# check that signal is not found if file does not exist
self.assertFalse(check_for_signal('test_signal'))
# Check that the signal is found when created
create_signal('test_signal')
self.assertTrue(check_for_signal('test_signal'))
# Check that the signal is removed after use
self.assertFalse(isfile('/tmp/mycroft/ipc/signal/test_signal'))
def test_check_signal(self):
if exists('/tmp/mycroft'):
rmtree('/tmp/mycroft')
# check that signal is not found if file does not exist
self.assertFalse(check_for_signal('test_signal'))
# Check that the signal is found when created
create_signal('test_signal')
self.assertTrue(check_for_signal('test_signal'))
# Check that the signal is removed after use
self.assertFalse(isfile('/tmp/mycroft/ipc/signal/test_signal'))
def on_message(self, message):
utterance = json.dumps(message)
print("*****Utterance : ", utterance)
if utterance:
if utterance == '"mic_on"':
create_signal('startListening')
else:
lang = 'en-us'
data = {"lang": lang, "session": "", "utterances": [utterance]}
ws.emit(Message('recognizer_loop:utterance', data))
t = Thread(target=self.newThread)
t.start()
def on_message(self, message):
utterance = message.strip()
LOG.info("Utterance : " + utterance)
if utterance:
if utterance == '"mic_on"':
create_signal('startListening')
else:
data = {"utterances": [utterance], "lang": lang}
context = {
"source": self.peer,
"destinatary": "skills",
"client_name": platform,
"peer": self.peer
}
self.emitter.emit(
Message("recognizer_loop:utterance", data, context))
def execute(self, sentence, ident=None, listen=False):
"""Convert sentence to speech, preprocessing out unsupported ssml
The method caches results if possible using the hash of the
sentence.
Arguments:
sentence: Sentence to be spoken
ident: Id reference to current interaction
listen: True if listen should be triggered at the end
of the utterance.
"""
sentence = self.validate_ssml(sentence)
create_signal("isSpeaking")
if self.phonetic_spelling:
for word in re.findall(r"[\w']+", sentence):
if word.lower() in self.spellings:
sentence = sentence.replace(word,
self.spellings[word.lower()])
chunks = self._preprocess_sentence(sentence)
# Apply the listen flag to the last chunk, set the rest to False
chunks = [(chunks[i], listen if i == len(chunks) - 1 else False)
for i in range(len(chunks))]
for sentence, l in chunks:
key = str(
hashlib.md5(sentence.encode('utf-8', 'ignore')).hexdigest())
wav_file = os.path.join(
mycroft.util.get_cache_directory("tts/" + self.tts_name),
key + '.' + self.audio_ext)
if os.path.exists(wav_file):
LOG.debug("TTS cache hit")
phonemes = self.load_phonemes(key)
else:
wav_file, phonemes = self.get_tts(sentence, wav_file)
if phonemes:
self.save_phonemes(key, phonemes)
vis = self.viseme(phonemes) if phonemes else None
self.queue.put((self.audio_ext, wav_file, vis, ident, l))
def handle_speak(event):
"""
Handle "speak" message
"""
config = ConfigurationManager.get()
ConfigurationManager.init(ws)
global _last_stop_signal
# Mild abuse of the signal system to allow other processes to detect
# when TTS is happening. See mycroft.util.is_speaking()
create_signal("isSpeaking")
utterance = event.data['utterance']
if event.data.get('expect_response', False):
ws.once('recognizer_loop:audio_output_end', _trigger_expect_response)
# This is a bit of a hack for Picroft. The analog audio on a Pi blocks
# for 30 seconds fairly often, so we don't want to break on periods
# (decreasing the chance of encountering the block). But we will
# keep the split for non-Picroft installs since it give user feedback
# faster on longer phrases.
#
# TODO: Remove or make an option? This is really a hack, anyway,
# so we likely will want to get rid of this when not running on Mimic
if not config.get('enclosure', {}).get('platform') == "picroft":
start = time.time()
chunks = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s',
utterance)
for chunk in chunks:
try:
mute_and_speak(chunk)
except KeyboardInterrupt:
raise
except:
logger.error('Error in mute_and_speak', exc_info=True)
if _last_stop_signal > start or check_for_signal('buttonPress'):
break
else:
mute_and_speak(utterance)
# This check will clear the "signal"
check_for_signal("isSpeaking")
def handle_speak(event):
global _last_stop_signal
# Mild abuse of the signal system to allow other processes to detect
# when TTS is happening. See mycroft.util.is_speaking()
create_signal("isSpeaking")
utterance = event.data['utterance']
expect_response = event.data.get('expect_response', False)
# This is a bit of a hack for Picroft. The analog audio on a Pi blocks
# for 30 seconds fairly often, so we don't want to break on periods
# (decreasing the chance of encountering the block). But we will
# keep the split for non-Picroft installs since it give user feedback
# faster on longer phrases.
#
# TODO: Remove or make an option? This is really a hack, anyway,
# so we likely will want to get rid of this when not running on Mimic
if not config.get('enclosure', {}).get('platform') == "picroft":
start = time.time()
chunks = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s',
utterance)
for chunk in chunks:
try:
mute_and_speak(chunk)
except KeyboardInterrupt:
raise
except:
logger.error('Error in mute_and_speak', exc_info=True)
if _last_stop_signal > start or check_for_signal('buttonPress'):
break
else:
mute_and_speak(utterance)
# This check will clear the "signal"
check_for_signal("isSpeaking")
if expect_response:
create_signal('startListening')
def execute(self, sentence, ident=None, listen=False):
"""Convert sentence to speech, preprocessing out unsupported ssml
The method caches results if possible using the hash of the
sentence.
Arguments:
sentence: Sentence to be spoken
ident: Id reference to current interaction
listen: True if listen should be triggered at the end
of the utterance.
"""
sentence = self.validate_ssml(sentence)
create_signal("isSpeaking")
try:
self._execute(sentence, ident, listen)
except Exception:
# If an error occurs end the audio sequence through an empty entry
self.queue.put(EMPTY_PLAYBACK_QUEUE_TUPLE)
# Re-raise to allow the Exception to be handled externally as well.
raise
def execute(self, sentence, ident=None):
"""request and play mimic2 wav audio
Args:
sentence (str): sentence to synthesize from mimic2
ident (optional): Defaults to None.
"""
create_signal("isSpeaking")
sentence = self._normalized_numbers(sentence)
chunks = sentence_chunker(sentence, self.chunk_size)
for idx, req in enumerate(self._requests(chunks)):
results = req.result().json()
audio = base64.b64decode(results['audio_base64'])
vis = self.visime(results['visimes'])
key = str(
hashlib.md5(chunks[idx].encode('utf-8', 'ignore')).hexdigest())
wav_file = os.path.join(get_cache_directory("tts"),
key + '.' + self.audio_ext)
with open(wav_file, 'wb') as f:
f.write(audio)
self.queue.put((self.audio_ext, wav_file, vis, ident))
def execute(self, sentence, ident=None):
"""
Convert sentence to speech, preprocessing out unsupported ssml
The method caches results if possible using the hash of the
sentence.
Args:
sentence: Sentence to be spoken
ident: Id reference to current interaction
"""
sentence = self.validate_ssml(sentence)
create_signal("isSpeaking")
if self.phonetic_spelling:
for word in re.findall(r"[\w']+", sentence):
if word.lower() in self.spellings:
sentence = sentence.replace(word,
self.spellings[word.lower()])
chunks = self._preprocess_sentence(sentence)
for sentence in chunks:
key = str(hashlib.md5(
sentence.encode('utf-8', 'ignore')).hexdigest())
wav_file = os.path.join(
mycroft.util.get_cache_directory("tts/" + self.tts_name),
key + '.' + self.audio_ext)
if os.path.exists(wav_file):
LOG.debug("TTS cache hit")
phonemes = self.load_phonemes(key)
else:
wav_file, phonemes = self.get_tts(sentence, wav_file)
if phonemes:
self.save_phonemes(key, phonemes)
vis = self.viseme(phonemes)
self.queue.put((self.audio_ext, wav_file, vis, ident))
def execute(self, sentence, ident=None):
"""request and play mimic2 wav audio
Args:
sentence (str): sentence to synthesize from mimic2
ident (optional): Defaults to None.
"""
create_signal("isSpeaking")
sentence = self._normalized_numbers(sentence)
# Use the phonetic_spelling mechanism from the TTS base class
if self.phonetic_spelling:
for word in re.findall(r"[\w']+", sentence):
if word.lower() in self.spellings:
sentence = sentence.replace(word,
self.spellings[word.lower()])
chunks = sentence_chunker(sentence, self.chunk_size)
try:
for idx, req in enumerate(self._requests(chunks)):
results = req.result().json()
audio = base64.b64decode(results['audio_base64'])
vis = self.visime(results['visimes'])
key = str(hashlib.md5(
chunks[idx].encode('utf-8', 'ignore')).hexdigest())
wav_file = os.path.join(
get_cache_directory("tts"),
key + '.' + self.audio_ext
)
with open(wav_file, 'wb') as f:
f.write(audio)
self.queue.put((self.audio_ext, wav_file, vis, ident))
except (ReadTimeout, ConnectionError, ConnectTimeout, HTTPError):
raise RemoteTTSTimeoutException(
"Mimic 2 remote server request timedout. falling back to mimic"
)
def execute(self, sentence, ident=None):
"""request and play mimic2 wav audio
Args:
sentence (str): sentence to synthesize from mimic2
ident (optional): Defaults to None.
"""
create_signal("isSpeaking")
sentence = self._normalized_numbers(sentence)
# Use the phonetic_spelling mechanism from the TTS base class
if self.phonetic_spelling:
for word in re.findall(r"[\w']+", sentence):
if word.lower() in self.spellings:
sentence = sentence.replace(word,
self.spellings[word.lower()])
chunks = sentence_chunker(sentence, self.chunk_size)
try:
for idx, req in enumerate(self._requests(chunks)):
results = req.result().json()
audio = base64.b64decode(results['audio_base64'])
vis = self.visime(results['visimes'])
key = str(hashlib.md5(
chunks[idx].encode('utf-8', 'ignore')).hexdigest())
wav_file = os.path.join(
get_cache_directory("tts"),
key + '.' + self.audio_ext
)
with open(wav_file, 'wb') as f:
f.write(audio)
self.queue.put((self.audio_ext, wav_file, vis, ident))
except (ReadTimeout, ConnectionError, ConnectTimeout, HTTPError):
raise RemoteTTSTimeoutException(
"Mimic 2 remote server request timedout. falling back to mimic"
)
def execute(self, sentence):
"""
Convert sentence to speech.
The method caches results if possible using the hash of the
sentence.
Args:
sentence: Sentence to be spoken
"""
create_signal("isSpeaking")
key = str(hashlib.md5(sentence.encode('utf-8', 'ignore')).hexdigest())
wav_file = os.path.join(mycroft.util.get_cache_directory("tts"),
key + '.' + self.type)
if os.path.exists(wav_file):
LOG.debug("TTS cache hit")
phonemes = self.load_phonemes(key)
else:
wav_file, phonemes = self.get_tts(sentence, wav_file)
if phonemes:
self.save_phonemes(key, phonemes)
self.queue.put((self.type, wav_file, self.visime(phonemes)))
def handle_confirm_yes(self, message):
if check_for_signal("StartSkippingWW", 0):
create_signal('skip_wake_word')
create_signal('restartedFromSkill')
self.speak("o k. Starting to skip wake words.", False)
# self.emitter.emit(Message('configuration.updated'))
# self.emitter.emit(Message('recognizer_loop:reload'))
self.emitter.emit(Message('recognizer_loop:restart'))
elif check_for_signal("StopSkippingWW", 0):
check_for_signal('skip_wake_word', 0)
create_signal('restartedFromSkill')
self.speak("o k. Stopping the skipping of wake words.", False)
# self.emitter.emit(Message('configuration.updated'))
# self.emitter.emit(Message('recognizer_loop:reload'))
self.emitter.emit(Message('recognizer_loop:restart'))
self.disable_intent('ConfirmYes')
self.disable_intent('ConfirmNo')
def process(self, data):
self.ws.emit(Message(data))
if "Command: system.version" in data:
# This happens in response to the "system.version" message
# sent during the construction of Enclosure()
self.ws.emit(Message("enclosure.started"))
if "mycroft.stop" in data:
create_signal('buttonPress')
self.ws.emit(Message("mycroft.stop"))
if "volume.up" in data:
self.ws.emit(
Message("VolumeSkill:IncreaseVolumeIntent",
{'play_sound': True}))
if "volume.down" in data:
self.ws.emit(
Message("VolumeSkill:DecreaseVolumeIntent",
{'play_sound': True}))
if "system.test.begin" in data:
self.ws.emit(Message('recognizer_loop:sleep'))
if "system.test.end" in data:
self.ws.emit(Message('recognizer_loop:wake_up'))
if "mic.test" in data:
mixer = Mixer()
prev_vol = mixer.getvolume()[0]
mixer.setvolume(35)
self.ws.emit(Message("speak", {
'utterance': "I am testing one two three"}))
time.sleep(0.5) # Prevents recording the loud button press
record("/tmp/test.wav", 3.0)
mixer.setvolume(prev_vol)
play_wav("/tmp/test.wav").communicate()
# Test audio muting on arduino
subprocess.call('speaker-test -P 10 -l 0 -s 1', shell=True)
if "unit.shutdown" in data:
self.ws.emit(
Message("enclosure.eyes.timedspin",
{'length': 12000}))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl poweroff -i', shell=True)
if "unit.reboot" in data:
self.ws.emit(
Message("enclosure.eyes.spin"))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
if "unit.setwifi" in data:
self.ws.emit(Message("mycroft.wifi.start"))
if "unit.factory-reset" in data:
self.ws.emit(
Message("enclosure.eyes.spin"))
subprocess.call(
'rm ~/.mycroft/identity/identity2.json',
shell=True)
self.ws.emit(Message("mycroft.wifi.reset"))
self.ws.emit(Message("mycroft.disable.ssh"))
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("reset to factory defaults")}))
time.sleep(5)
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
if "unit.enable-ssh" in data:
# This is handled by the wifi client
self.ws.emit(Message("mycroft.enable.ssh"))
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("ssh enabled")}))
if "unit.disable-ssh" in data:
# This is handled by the wifi client
self.ws.emit(Message("mycroft.disable.ssh"))
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("ssh disabled")}))
def process(self, data):
self.ws.emit(Message(data))
if "Command: system.version" in data:
self.ws.emit(Message("enclosure.start"))
if "mycroft.stop" in data:
create_signal('buttonPress') # FIXME - Must use WS instead
self.ws.emit(Message("mycroft.stop"))
if "volume.up" in data:
self.ws.emit(
Message("IncreaseVolumeIntent", {'play_sound': True}))
if "volume.down" in data:
self.ws.emit(
Message("DecreaseVolumeIntent", {'play_sound': True}))
if "system.test.begin" in data:
self.ws.emit(Message('recognizer_loop:sleep'))
if "system.test.end" in data:
self.ws.emit(Message('recognizer_loop:wake_up'))
if "mic.test" in data:
mixer = Mixer()
prev_vol = mixer.getvolume()[0]
mixer.setvolume(35)
self.ws.emit(Message("speak", {
'utterance': "I am testing one two three"}))
time.sleep(0.5) # Prevents recording the loud button press
record("/tmp/test.wav", 3.0)
mixer.setvolume(prev_vol)
play_wav("/tmp/test.wav").communicate()
# Test audio muting on arduino
subprocess.call('speaker-test -P 10 -l 0 -s 1', shell=True)
if "unit.shutdown" in data:
self.ws.emit(
Message("enclosure.eyes.timedspin",
{'length': 12000}))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl poweroff -i', shell=True)
if "unit.reboot" in data:
self.ws.emit(
Message("enclosure.eyes.spin"))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
if "unit.setwifi" in data:
self.ws.emit(Message("mycroft.wifi.start"))
if "unit.factory-reset" in data:
subprocess.call(
'rm ~/.mycroft/identity/identity2.json',
shell=True)
self.ws.emit(
Message("enclosure.eyes.spin"))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
def test_is_speaking(self):
create_signal('isSpeaking')
self.assertTrue(mycroft.audio.is_speaking())
# Check that the signal hasn't been removed
self.assertTrue(check_for_signal('isSpeaking'))
self.assertFalse(mycroft.audio.is_speaking())
def test_create_signal(self):
create_signal('test_signal')
self.assertTrue(isfile('/tmp/mycroft/ipc/signal/test_signal'))
def test_create_signal(self):
create_signal('test_signal')
self.assertTrue(
isfile(join(gettempdir(), 'mycroft/ipc/signal/test_signal')))
def process(self, data):
# TODO: Look into removing this emit altogether.
# We need to check if any other serial bus messages
# are handled by other parts of the code
if "mycroft.stop" not in data:
self.ws.emit(Message(data))
if "Command: system.version" in data:
# This happens in response to the "system.version" message
# sent during the construction of Enclosure()
self.ws.emit(Message("enclosure.started"))
if "mycroft.stop" in data:
if has_been_paired():
create_signal('buttonPress')
self.ws.emit(Message("mycroft.stop"))
if "volume.up" in data:
self.ws.emit(
Message("VolumeSkill:IncreaseVolumeIntent",
{'play_sound': True}))
if "volume.down" in data:
self.ws.emit(
Message("VolumeSkill:DecreaseVolumeIntent",
{'play_sound': True}))
if "system.test.begin" in data:
self.ws.emit(Message('recognizer_loop:sleep'))
if "system.test.end" in data:
self.ws.emit(Message('recognizer_loop:wake_up'))
if "mic.test" in data:
mixer = Mixer()
prev_vol = mixer.getvolume()[0]
mixer.setvolume(35)
self.ws.emit(Message("speak", {
'utterance': "I am testing one two three"}))
time.sleep(0.5) # Prevents recording the loud button press
record("/tmp/test.wav", 3.0)
mixer.setvolume(prev_vol)
play_wav("/tmp/test.wav").communicate()
# Test audio muting on arduino
subprocess.call('speaker-test -P 10 -l 0 -s 1', shell=True)
if "unit.shutdown" in data:
self.ws.emit(
Message("enclosure.eyes.timedspin",
{'length': 12000}))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl poweroff -i', shell=True)
if "unit.reboot" in data:
self.ws.emit(Message("enclosure.eyes.spin"))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
if "unit.setwifi" in data:
self.ws.emit(Message("mycroft.wifi.start"))
if "unit.factory-reset" in data:
self.ws.emit(Message("enclosure.eyes.spin"))
subprocess.call(
'rm ~/.mycroft/identity/identity2.json',
shell=True)
self.ws.emit(Message("mycroft.wifi.reset"))
self.ws.emit(Message("mycroft.disable.ssh"))
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("reset to factory defaults")}))
wait_while_speaking()
self.ws.emit(Message("enclosure.mouth.reset"))
self.ws.emit(Message("enclosure.eyes.spin"))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
if "unit.enable-ssh" in data:
# This is handled by the wifi client
self.ws.emit(Message("mycroft.enable.ssh"))
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("ssh enabled")}))
if "unit.disable-ssh" in data:
# This is handled by the wifi client
self.ws.emit(Message("mycroft.disable.ssh"))
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("ssh disabled")}))
def process(self, data):
self.ws.emit(Message(data))
if "Command: system.version" in data:
self.ws.emit(Message("enclosure.start"))
if "teddy.start" in data:
LOG.info("Got record start button")
#self.ws.emit(Message("manual.record.start"))
create_signal(
'startRecordingButton') # FIXME - Must use WS instead
if "teddy.stop" in data:
LOG.info("Got record stop button")
#self.ws.emit(Message("manual.record.stop"))
create_signal('stopRecordingButton') # FIXME - Must use WS instead
if "teddy.mute" in data:
#self.ws.emit(Message("manual.mute"))
#create_signal('muteButton') # FIXME - Must use WS instead
self.ws.emit(Message('recognizer_loop:mute'))
if "mycroft.stop" in data:
create_signal('buttonPress') # FIXME - Must use WS instead
self.ws.emit(Message("mycroft.stop"))
if "volume.up" in data:
self.ws.emit(Message("IncreaseVolumeIntent", {'play_sound': True}))
if "volume.down" in data:
self.ws.emit(Message("DecreaseVolumeIntent", {'play_sound': True}))
if "system.test.begin" in data:
self.ws.emit(Message('recognizer_loop:sleep'))
if "system.test.end" in data:
self.ws.emit(Message('recognizer_loop:wake_up'))
if "mic.test" in data:
mixer = Mixer()
prev_vol = mixer.getvolume()[0]
mixer.setvolume(35)
self.ws.emit(
Message("speak", {'utterance': "I am testing one two three"}))
time.sleep(0.5) # Prevents recording the loud button press
record("/tmp/test.wav", 3.0)
mixer.setvolume(prev_vol)
play_wav("/tmp/test.wav").communicate()
# Test audio muting on arduino
subprocess.call('speaker-test -P 10 -l 0 -s 1', shell=True)
if "unit.shutdown" in data:
self.ws.emit(Message("enclosure.eyes.timedspin",
{'length': 12000}))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl poweroff -i', shell=True)
if "unit.reboot" in data:
self.ws.emit(Message("enclosure.eyes.spin"))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
if "unit.setwifi" in data:
self.ws.emit(Message("mycroft.wifi.start"))
if "unit.factory-reset" in data:
subprocess.call('rm ~/.mycroft/identity/identity2.json',
shell=True)
self.ws.emit(Message("enclosure.eyes.spin"))
self.ws.emit(Message("enclosure.mouth.reset"))
subprocess.call('systemctl reboot -i', shell=True)
def process(self, data):
# TODO: Look into removing this emit altogether.
# We need to check if any other serial bus messages
# are handled by other parts of the code
if "mycroft.stop" not in data:
self.ws.emit(Message(data))
if "Command: system.version" in data:
# This happens in response to the "system.version" message
# sent during the construction of Enclosure()
self.ws.emit(Message("enclosure.started"))
if "mycroft.stop" in data:
if has_been_paired():
create_signal('buttonPress')
self.ws.emit(Message("mycroft.stop"))
if "volume.up" in data:
self.ws.emit(Message("mycroft.volume.increase",
{'play_sound': True}))
if "volume.down" in data:
self.ws.emit(Message("mycroft.volume.decrease",
{'play_sound': True}))
if "system.test.begin" in data:
self.ws.emit(Message('recognizer_loop:sleep'))
if "system.test.end" in data:
self.ws.emit(Message('recognizer_loop:wake_up'))
if "mic.test" in data:
mixer = Mixer()
prev_vol = mixer.getvolume()[0]
mixer.setvolume(35)
self.ws.emit(Message("speak", {
'utterance': "I am testing one two three"}))
time.sleep(0.5) # Prevents recording the loud button press
record("/tmp/test.wav", 3.0)
mixer.setvolume(prev_vol)
play_wav("/tmp/test.wav").communicate()
# Test audio muting on arduino
subprocess.call('speaker-test -P 10 -l 0 -s 1', shell=True)
if "unit.shutdown" in data:
# Eyes to soft gray on shutdown
self.ws.emit(Message("enclosure.eyes.color",
{'r': 70, 'g': 65, 'b': 69}))
self.ws.emit(
Message("enclosure.eyes.timedspin",
{'length': 12000}))
self.ws.emit(Message("enclosure.mouth.reset"))
time.sleep(0.5) # give the system time to pass the message
self.ws.emit(Message("system.shutdown"))
if "unit.reboot" in data:
# Eyes to soft gray on reboot
self.ws.emit(Message("enclosure.eyes.color",
{'r': 70, 'g': 65, 'b': 69}))
self.ws.emit(Message("enclosure.eyes.spin"))
self.ws.emit(Message("enclosure.mouth.reset"))
time.sleep(0.5) # give the system time to pass the message
self.ws.emit(Message("system.reboot"))
if "unit.setwifi" in data:
self.ws.emit(Message("system.wifi.setup", {'lang': self.lang}))
if "unit.factory-reset" in data:
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("reset to factory defaults")}))
subprocess.call(
'rm ~/.mycroft/identity/identity2.json',
shell=True)
self.ws.emit(Message("system.wifi.reset"))
self.ws.emit(Message("system.ssh.disable"))
wait_while_speaking()
self.ws.emit(Message("enclosure.mouth.reset"))
self.ws.emit(Message("enclosure.eyes.spin"))
self.ws.emit(Message("enclosure.mouth.reset"))
time.sleep(5) # give the system time to process all messages
self.ws.emit(Message("system.reboot"))
if "unit.enable-ssh" in data:
# This is handled by the wifi client
self.ws.emit(Message("system.ssh.enable"))
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("ssh enabled")}))
if "unit.disable-ssh" in data:
# This is handled by the wifi client
self.ws.emit(Message("system.ssh.disable"))
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("ssh disabled")}))
if "unit.enable-learning" in data or "unit.disable-learning" in data:
enable = 'enable' in data
word = 'enabled' if enable else 'disabled'
LOG.info("Setting opt_in to: " + word)
new_config = {'opt_in': enable}
user_config = LocalConf(USER_CONFIG)
user_config.merge(new_config)
user_config.store()
self.ws.emit(Message("speak", {
'utterance': mycroft.dialog.get("learning " + word)}))
def test_is_speaking(self):
create_signal('isSpeaking')
self.assertTrue(mycroft.audio.is_speaking())
# Check that the signal hasn't been removed
self.assertTrue(check_for_signal('isSpeaking'))
self.assertFalse(mycroft.audio.is_speaking())
def begin_audio(self):
"""Helper function for child classes to call in execute()"""
self.ws.emit(Message("recognizer_loop:audio_output_start"))
create_signal("isSpeaking")
def _start_listener(message):
"""
Force Mycroft to start listening (as if 'Hey Mycroft' was spoken)
"""
create_signal('startListening')
def _trigger_expect_response(message):
"""
Makes mycroft start listening on 'recognizer_loop:audio_output_end'
"""
create_signal('startListening')
def test_create_signal(self):
create_signal('test_signal')
self.assertTrue(isfile('/tmp/mycroft/ipc/signal/test_signal'))
def _trigger_expect_response(message):
"""
Makes mycroft start listening on 'recognizer_loop:audio_output_end'
"""
create_signal('startListening')
def process(self, data):
# TODO: Look into removing this emit altogether.
# We need to check if any other serial bus messages
# are handled by other parts of the code
if "mycroft.stop" not in data:
self.bus.emit(Message(data))
if "Command: system.version" in data:
# This happens in response to the "system.version" message
# sent during the construction of Enclosure()
self.bus.emit(Message("enclosure.started"))
if "mycroft.stop" in data:
if has_been_paired():
create_signal('buttonPress')
self.bus.emit(Message("mycroft.stop"))
if "volume.up" in data:
self.bus.emit(Message("mycroft.volume.increase",
{'play_sound': True}))
if "volume.down" in data:
self.bus.emit(Message("mycroft.volume.decrease",
{'play_sound': True}))
if "system.test.begin" in data:
self.bus.emit(Message('recognizer_loop:sleep'))
if "system.test.end" in data:
self.bus.emit(Message('recognizer_loop:wake_up'))
if "mic.test" in data:
mixer = Mixer()
prev_vol = mixer.getvolume()[0]
mixer.setvolume(35)
self.bus.emit(Message("speak", {
'utterance': "I am testing one two three"}))
time.sleep(0.5) # Prevents recording the loud button press
record("/tmp/test.wav", 3.0)
mixer.setvolume(prev_vol)
play_wav("/tmp/test.wav").communicate()
# Test audio muting on arduino
subprocess.call('speaker-test -P 10 -l 0 -s 1', shell=True)
if "unit.shutdown" in data:
# Eyes to soft gray on shutdown
# self.bus.emit(Message("enclosure.eyes.color",
# {'r': 70, 'g': 65, 'b': 69}))
# self.bus.emit(
# Message("enclosure.eyes.timedspin",
# {'length': 12000}))
# self.bus.emit(Message("enclosure.mouth.reset"))
time.sleep(0.5) # give the system time to pass the message
self.bus.emit(Message("system.shutdown"))
if "unit.reboot" in data:
# Eyes to soft gray on reboot
# self.bus.emit(Message("enclosure.eyes.color",
# {'r': 70, 'g': 65, 'b': 69}))
# self.bus.emit(Message("enclosure.eyes.spin"))
# self.bus.emit(Message("enclosure.mouth.reset"))
time.sleep(0.5) # give the system time to pass the message
self.bus.emit(Message("system.reboot"))
if "unit.setwifi" in data:
self.bus.emit(Message("system.wifi.setup", {'lang': self.lang}))
if "unit.factory-reset" in data:
self.bus.emit(Message("speak", {
'utterance': mycroft.dialog.get("reset to factory defaults")}))
subprocess.call(
'rm ~/.mycroft/identity/identity2.json',
shell=True)
self.bus.emit(Message("system.wifi.reset"))
self.bus.emit(Message("system.ssh.disable"))
wait_while_speaking()
# self.bus.emit(Message("enclosure.mouth.reset"))
# self.bus.emit(Message("enclosure.eyes.spin"))
# self.bus.emit(Message("enclosure.mouth.reset"))
time.sleep(5) # give the system time to process all messages
self.bus.emit(Message("system.reboot"))
if "unit.enable-ssh" in data:
# This is handled by the wifi client
self.bus.emit(Message("system.ssh.enable"))
self.bus.emit(Message("speak", {
'utterance': mycroft.dialog.get("ssh enabled")}))
if "unit.disable-ssh" in data:
# This is handled by the wifi client
self.bus.emit(Message("system.ssh.disable"))
self.bus.emit(Message("speak", {
'utterance': mycroft.dialog.get("ssh disabled")}))
if "unit.enable-learning" in data or "unit.disable-learning" in data:
enable = 'enable' in data
word = 'enabled' if enable else 'disabled'
LOG.info("Setting opt_in to: " + word)
new_config = {'opt_in': enable}
user_config = LocalConf(USER_CONFIG)
user_config.merge(new_config)
user_config.store()
self.bus.emit(Message("speak", {
'utterance': mycroft.dialog.get("learning " + word)}))
def _start_listener(message):
"""
Force Mycroft to start listening (as if 'Hey Mycroft' was spoken)
"""
create_signal('startListening')