def __init__(self, **kwargs):
super(RFIDReader, self).__init__(**kwargs)
Thread.__init__(self, name=RFIDReader)
Utils.print_info('[NFC_Reader] Starting manager ...')
self.synapse_list = list(super(RFIDReader, self).get_list_synapse())
if self.synapse_list is None:
self.synapse_list = list()
def __init__(self, **kwargs):
super(Editor, self).__init__(**kwargs)
# the args from the neuron configuration
listen_ip = kwargs.get('listen_ip', '0.0.0.0')
port = kwargs.get('port', 8000)
ignore_pattern = kwargs.get('ignore_pattern', None)
dir_first = kwargs.get('dir_first', False)
hide_hidden = kwargs.get('hide_hidden', False)
page_title = kwargs.get('page_title', "Kalliope Editor")
stop_server = kwargs.get('stop_server', False)
if stop_server:
self.stop_http_server()
Utils.print_info("[ Editor ] Editor stopped")
else:
global IGNORE_PATTERN, DIRSFIRST, HIDEHIDDEN, PAGE_TITLE
IGNORE_PATTERN = ignore_pattern
DIRSFIRST = dir_first
HIDEHIDDEN = hide_hidden
PAGE_TITLE = page_title
if self.stop_http_server():
server = EditorThread(listen_ip, int(port))
server.daemon = True
server.start()
Cortex.save('EditorServerThread', server)
def downloadPreciseEngine(self):
import json
import requests
import tarfile
Utils.print_info("[Preicse] Precise engine not present, starting download now")
url = "https://api.github.com/repos/MycroftAI/mycroft-precise/releases/latest"
response = requests.get(url)
if response.status_code == 200:
download_url = None
arch = self.settings.machine
for asset in response.json()["assets"]:
if arch in asset.get("name"):
if asset.get("name").startswith("precise-engine") and asset.get("name").endswith(".tar.gz"):
download_name = asset.get("name")
download_url = asset.get('browser_download_url')
filepath = os.path.join(TOP_DIR, download_name)
if download_url:
Utils.print_info("[Precise] Downloading %s this can take a moment" % download_name)
file = requests.get(download_url)
if file.status_code == 200:
with open(filepath, 'wb') as f:
f.write(file.content)
with tarfile.open(filepath) as tar:
tar.extractall(path=TOP_DIR)
os.remove(filepath)
return True
return False
def ReadListItems(self, list):
for l in self.keep.all():
if l.title == list:
return l.text
break
else:
Utils.print_info('[Gnote] List %s not found' % list)
return False
def stop_http_server(self):
running_server = Cortex.get_from_key("EditorServerThread")
if running_server:
Utils.print_info("[ Editor ] Editor is running, stopping now...")
running_server.shutdown_server()
while not running_server.is_down:
time.sleep(0.1)
return True
def __init__(self, listen_ip, port):
super(EditorThread, self).__init__()
self.is_down = False
server_address = (listen_ip, port)
self.httpd = SimpleServer(server_address, RequestHandler)
Utils.print_info(
('[ Editor ] Listening on: http://%s:%s') %
(self.httpd.server_address[0], self.httpd.server_address[1]))
def run(self):
"""
Start the thread that listen the microphone and then give the audio to the callback method
"""
Utils.print_info("Say something!")
self.stop_thread = self.recognizer.listen_in_background(self.microphone, self.callback)
while not self.kill_yourself:
sleep(0.1)
logger.debug("kill the speech recognition process")
self.stop_thread()
def google_engine(self, question):
result = None
g_a = GoogleAnswer(question)
result = g_a.get_answer()
if result:
Utils.print_info('Found answer on Google')
result = self.format_result(result[0])
else:
Utils.print_info('No answer found on Google')
return result
def run(self):
"""
Creates an input audio stream, initializes wake word detection (Porcupine) object, and monitors the audio
stream for occurrences of the wake word(s).
"""
num_keywords = len(self._keyword_file_paths)
keyword_names =\
[os.path.basename(x).replace('.ppn', '').replace('_compressed', '').split('_')[0] for x in self._keyword_file_paths]
for keyword_name, sensitivity in zip(keyword_names,
self._sensitivities):
logger.debug('Listening for %s with sensitivity of %s' %
(keyword_name, sensitivity))
self.porcupine = Porcupine(library_path=self._library_path,
model_file_path=self._model_file_path,
keyword_file_paths=self._keyword_file_paths,
sensitivities=self._sensitivities)
self.pa = pyaudio.PyAudio()
self.audio_stream = self.pa.open(
rate=self.porcupine.sample_rate,
channels=1,
format=pyaudio.paInt16,
input=True,
frames_per_buffer=self.porcupine.frame_length,
input_device_index=self._input_device_index)
logger.debug("[Porcupine] detecting...")
while not self.kill_received:
if not self.paused:
callback = None
pcm = self.audio_stream.read(self.porcupine.frame_length)
pcm = struct.unpack_from("h" * self.porcupine.frame_length,
pcm)
result = self.porcupine.process(pcm)
if num_keywords == 1 and result:
message = "Keyword " + str(keyword_names[0]) + " detected"
callback = self.detected_callback
elif num_keywords > 1 and result >= 0:
message = "Keyword " + str(
keyword_names[result]) + " detected"
callback = self.detected_callback
if callback is not None:
logger.debug(message)
Utils.print_info(message)
callback()
logger.debug("[Porcupine] detect voice break")
break
def ddg_engine(self, question):
result = None
ddg = DuckDuckGo(self.translate_text(question, is_question=True))
result = ddg.get_answer()
if result:
result = self.format_result(self.translate_text(result))
Utils.print_info('Found answer on DuckDuckGo')
else:
Utils.print_info('No answer found on DuckDuckGo')
return result
def __init__(self):
super(Order, self).__init__()
Utils.print_info('Starting voice order manager')
# load settings and brain from singleton
sl = SettingLoader()
self.settings = sl.settings
self.brain = BrainLoader().get_brain()
# keep in memory the order to process
self.order_to_process = None
# get the player instance
self.player_instance = PlayerLauncher.get_player(settings=self.settings)
# save an instance of the trigger
self.trigger_instance = None
self.trigger_callback_called = False
self.is_trigger_muted = False
# save the current order listener
self.order_listener = None
self.order_listener_callback_called = False
# boolean used to know id we played the on ready notification at least one time
self.on_ready_notification_played_once = False
# rpi setting for led and mute button
self.init_rpi_utils()
# Initialize the state machine
self.machine = Machine(model=self, states=Order.states, initial='init', queued=True)
# define transitions
self.machine.add_transition('start_trigger', ['init', 'analysing_order'], 'starting_trigger')
self.machine.add_transition('play_ready_sound', 'starting_trigger', 'playing_ready_sound')
self.machine.add_transition('wait_trigger_callback', 'playing_ready_sound', 'waiting_for_trigger_callback')
self.machine.add_transition('stop_trigger', 'waiting_for_trigger_callback', 'stopping_trigger')
self.machine.add_transition('play_wake_up_answer', 'stopping_trigger', 'playing_wake_up_answer')
self.machine.add_transition('wait_for_order', 'playing_wake_up_answer', 'waiting_for_order_listener_callback')
self.machine.add_transition('analyse_order', 'playing_wake_up_answer', 'analysing_order')
self.machine.add_ordered_transitions()
# add method which are called when changing state
self.machine.on_enter_starting_trigger('start_trigger_process')
self.machine.on_enter_playing_ready_sound('play_ready_sound_process')
self.machine.on_enter_waiting_for_trigger_callback('waiting_for_trigger_callback_thread')
self.machine.on_enter_playing_wake_up_answer('play_wake_up_answer_thread')
self.machine.on_enter_stopping_trigger('stop_trigger_process')
self.machine.on_enter_start_order_listener('start_order_listener_thread')
self.machine.on_enter_waiting_for_order_listener_callback('waiting_for_order_listener_callback_thread')
self.machine.on_enter_analysing_order('analysing_order_thread')
def DeleteList(self, list):
my_list = None
for l in self.keep.all():
if l.title.lower() == list.lower():
my_list = l
if my_list:
my_list.delete()
self.syncKeep()
Utils.print_info('[Gnote] List %s deleted' % list)
return True
else:
Utils.print_info('[Gnote] List %s not found' % list)
return False
def waiting_for_trigger_callback_thread(self):
"""
Method to print in debug that the main process is waiting for a trigger detection
"""
logger.debug("[MainController] Entering state: %s" % self.state)
if self.is_trigger_muted: # the user asked to mute inside the mute neuron
Utils.print_info("Kalliope is muted")
self.trigger_instance.pause()
else:
Utils.print_info("Waiting for trigger detection")
# this loop is used to keep the main thread alive
while not self.trigger_callback_called:
sleep(0.1)
self.next_state()
def set_mute_status(self, muted=False):
"""
Define is the trigger is listening or not
:param muted: Boolean. If true, kalliope is muted
"""
logger.debug("[MainController] Mute button pressed. Switch trigger process to muted: %s" % muted)
if muted:
self.trigger_instance.pause()
self.is_trigger_muted = True
Utils.print_info("Kalliope now muted")
else:
self.trigger_instance.unpause()
self.is_trigger_muted = False
Utils.print_info("Kalliope now listening for trigger detection")
def __init__(self):
super(SignalModule, self).__init__()
Thread.__init__(self, name=Order)
Utils.print_info('Starting order signal')
# load settings and brain from singleton
sl = SettingLoader()
self.settings = sl.settings
self.brain = BrainLoader().brain
# keep in memory the order to process
self.order_to_process = None
# get the player instance
self.player_instance = PlayerLauncher.get_player(settings=self.settings)
# save an instance of the trigger
self.trigger_instance = None
self.trigger_callback_called = False
# variable from notifications
self.skip_trigger = False # keep the status of the trigger, if true we can skip it in the statue machine
self.counter_max_retry = 0 # 0 means disabled
# save the current order listener
self.order_listener = None
self.order_listener_callback_called = False
# Initialize the state machine
self.machine = Machine(model=self, states=Order.states, initial='init', queued=True)
# define transitions
self.machine.add_transition('start_trigger', 'init', 'starting_trigger')
self.machine.add_transition('unpause_trigger', 'analysing_order', 'unpausing_trigger')
self.machine.add_transition('wait_trigger_callback', 'unpausing_trigger', 'waiting_for_trigger_callback')
self.machine.add_transition('pause_trigger', 'waiting_for_trigger_callback', 'pausing_trigger')
self.machine.add_transition('wait_for_order', 'pausing_trigger', 'waiting_for_order_listener_callback')
self.machine.add_transition('analyse_order', 'waiting_for_order_listener_callback', 'analysing_order')
self.machine.add_transition('start_order_listener', 'analysing_order', 'start_order_listener')
self.machine.add_ordered_transitions()
# add method which are called when changing state
self.machine.on_enter_starting_trigger('start_trigger_process')
self.machine.on_enter_unpausing_trigger('unpausing_trigger_process')
self.machine.on_enter_waiting_for_trigger_callback('waiting_for_trigger_callback_thread')
self.machine.on_enter_pausing_trigger('pause_trigger_process')
self.machine.on_enter_start_order_listener('start_order_listener_thread')
self.machine.on_enter_waiting_for_order_listener_callback('waiting_for_order_listener_callback_thread')
self.machine.on_enter_analysing_order('analysing_order_thread')
def wa_engine(self, question):
result = None
try:
key = self.engines['wolfram_alpha']['key']
except KeyError:
raise MissingParameterException(
"API key is missing or is incorrect. Please set a valid API key."
)
try:
option = self.engines['wolfram_alpha']['option']
if option not in ["spoken_answer", "short_answer"]:
raise MissingParameterException(
"%s is not a valid option. Valid options are short_answer or spoken_answer."
% option)
except KeyError:
option = "spoken_answer"
try:
unit = self.engines['wolfram_alpha']['unit']
if unit.lower() not in ["metric", "imperial"]:
raise MissingParameterException(
"%s is not a valid unit. Valid units are metric or imperial."
% unit)
except KeyError:
unit = "metric"
if self.language:
question = self.translate_question(question, self.language)
w_a = WolframAlpha(question, key, unit.lower())
if option == "spoken_answer":
result = w_a.spoken_answer()
if result is None:
result = w_a.short_answer()
if option == "short_answer":
result = w_a.short_answer()
if result:
if self.language:
result = self.translate_answer(result, self.language)
result = self.format_result(result)
Utils.print_info('Found answer on Wolfram Alpha')
else:
Utils.print_info('No answer found on Wolfram Alpha')
return result
def waiting_for_trigger_callback_thread(self):
"""
Method to print in debug that the main process is waiting for a trigger detection
"""
logger.debug("[Order] Entering state: %s" % self.state)
if self.settings.options.deaf: # the user asked to deaf inside the deaf neuron
Utils.print_info("Kalliope is deaf")
self.trigger_instance.pause()
else:
Utils.print_info("Waiting for trigger detection")
# this loop is used to keep the main thread alive
while not self.trigger_callback_called:
sleep(0.1)
# if here, then the trigger has been called
HookManager.on_triggered()
self.next_state()
def waiting_for_trigger_callback_thread(self):
"""
Method to print in debug that the main process is waiting for a trigger detection
"""
logger.debug("[Order] Entering state: %s" % self.state)
if self.settings.options.deaf: # the user asked to deaf inside the deaf neuron
Utils.print_info("Kalliope is deaf")
self.trigger_instance.pause()
else:
Utils.print_info("Waiting for trigger detection")
# this loop is used to keep the main thread alive
while not self.trigger_callback_called:
sleep(0.1)
# if here, then the trigger has been called
HookManager.on_triggered()
self.next_state()
def run(self):
"""
Start the thread that listen the microphone and then give the audio to the callback method
"""
if self.audio_stream is None:
Utils.print_info("Say something!")
try:
with self.microphone as source:
logger.debug("[SpeechRecognition] STT timeout: %s" % self.settings.options.stt_timeout)
self.audio_stream = self.recognizer.listen(source, timeout=self.settings.options.stt_timeout)
except sr.WaitTimeoutError:
logger.debug("[SpeechRecognition] timeout reached while waiting for audio input")
self.audio_stream = None
logger.debug("[SpeechRecognition] end of speech recognition process")
self.callback(self.recognizer, self.audio_stream)
def ddg_engine(self, question):
result = None
if self.language:
question = self.translate_question(question, self.language)
ddg = DuckDuckGo(question)
result = ddg.get_answer()
if result:
if self.language:
result = self.translate_answer(result, self.language)
result = self.format_result(result)
Utils.print_info('Found answer on DuckDuckGo')
else:
Utils.print_info('No answer found on DuckDuckGo')
return result
def __init__(self, audio_file=None):
"""
Thread used to caught n audio from the microphone and pass it to a callback method
"""
super(SpeechRecognition, self).__init__()
self.recognizer = sr.Recognizer()
self.microphone = sr.Microphone()
self.callback = None
self.stop_thread = None
self.kill_yourself = False
self.audio_stream = None
# get global configuration
sl = SettingLoader()
self.settings = sl.settings
if audio_file is None:
# audio file not set, we need to capture a sample from the microphone
with self.microphone as source:
if self.settings.options.adjust_for_ambient_noise_second > 0:
# threshold is calculated from capturing ambient sound
logger.debug(
"[SpeechRecognition] threshold calculated by "
"capturing ambient noise during %s seconds" %
self.settings.options.adjust_for_ambient_noise_second)
Utils.print_info(
"[SpeechRecognition] capturing ambient sound during %s seconds"
%
self.settings.options.adjust_for_ambient_noise_second)
self.recognizer.adjust_for_ambient_noise(
source,
duration=self.settings.options.
adjust_for_ambient_noise_second)
else:
# threshold is defined manually
logger.debug(
"[SpeechRecognition] threshold defined by settings: %s"
% self.settings.options.energy_threshold)
self.recognizer.energy_threshold = self.settings.options.energy_threshold
Utils.print_info("[SpeechRecognition] Threshold set to: %s" %
self.recognizer.energy_threshold)
else:
# audio file provided
with sr.AudioFile(audio_file) as source:
self.audio_stream = self.recognizer.record(
source) # read the entire audio file
def run(self):
logger.debug("detecting...")
while True:
if not self.paused_loop:
data = self.stream.read()
if len(data) > 0:
self.stream.write(data)
if self.found_keyword:
self.pause() # We start pausing it here, to avoid double activations
message = "[Precise] Keyword detected"
Utils.print_info(message)
logger.debug(message)
self.detected_callback()
time.sleep(0.01)
logger.debug("finished")
def __init__(self):
super(SignalModule, self).__init__()
Thread.__init__(self, name=Order)
Utils.print_info('Starting order signal')
# load settings and brain from singleton
sl = SettingLoader()
self.settings = sl.settings
self.brain = BrainLoader().brain
# keep in memory the order to process
self.order_to_process = None
# get the player instance
self.player_instance = PlayerLauncher.get_player(settings=self.settings)
# save an instance of the trigger
self.trigger_instance = None
self.trigger_callback_called = False
self.skip_trigger = False # keep the status of the trigger, if true we can skip it in the statue machine
# save the current order listener
self.order_listener = None
self.order_listener_callback_called = False
# Initialize the state machine
self.machine = Machine(model=self, states=Order.states, initial='init', queued=True)
# define transitions
self.machine.add_transition('start_trigger', ['init', 'analysing_order'], 'starting_trigger')
self.machine.add_transition('wait_trigger_callback', 'starting_trigger', 'waiting_for_trigger_callback')
self.machine.add_transition('stop_trigger', 'waiting_for_trigger_callback', 'stopping_trigger')
self.machine.add_transition('wait_for_order', 'stopping_trigger', 'waiting_for_order_listener_callback')
self.machine.add_transition('analyse_order', 'waiting_for_order_listener_callback', 'analysing_order')
self.machine.add_transition('start_order_listener', 'analysing_order', 'start_order_listener')
self.machine.add_ordered_transitions()
# add method which are called when changing state
self.machine.on_enter_starting_trigger('start_trigger_process')
self.machine.on_enter_waiting_for_trigger_callback('waiting_for_trigger_callback_thread')
self.machine.on_enter_stopping_trigger('stop_trigger_process')
self.machine.on_enter_start_order_listener('start_order_listener_thread')
self.machine.on_enter_waiting_for_order_listener_callback('waiting_for_order_listener_callback_thread')
self.machine.on_enter_analysing_order('analysing_order_thread')
def run(self):
"""
Start the thread that listen the microphone and then give the audio to the callback method
"""
if self.audio_stream is None:
Utils.print_info("Say something!")
# Turn on the listening led if we are on a Raspberry
if self.settings.rpi_settings:
if self.settings.rpi_settings.pin_led_listening:
RpiUtils.switch_pin_to_on(
self.settings.rpi_settings.pin_led_listening)
self.stop_thread = self.recognizer.listen_in_background(
self.microphone, self.callback)
while not self.kill_yourself:
sleep(0.1)
logger.debug("kill the speech recognition process")
self.stop_thread()
else:
self.callback(self.recognizer, self.audio_stream)
def DeleteItem(self, list, items):
my_list = None
processed_items = []
for l in self.keep.all():
if l.title.lower() == list.lower():
my_list = l
break
if my_list:
for item in items:
for l in my_list.items:
if l.text.lower() == item.lower():
l.delete()
Utils.print_info('[Gnote] Item %s from %s deleted' %
(item, list))
processed_items.append(item)
self.syncKeep()
return processed_items
else:
Utils.print_info('[Gnote] List %s not found' % list)
return False
def UnCheckItem(self, list, items):
my_list = None
processed_items = []
for l in self.keep.all():
if l.title == list:
my_list = l
break
if my_list:
for item in items:
for i in my_list.items:
if i.text.lower() == item:
i.checked = False
Utils.print_info('[Gnote] Item %s on %s unchecked' %
(item.replace("☐ ", ""), list))
processed_items.append(item)
self.syncKeep()
return processed_items
else:
Utils.print_info('[Gnote] List %s not found' % list)
return False
def __init__(self, audio_file=None):
"""
Thread used to caught n audio from the microphone and pass it to a callback method
"""
super(SpeechRecognition, self).__init__()
self.recognizer = sr.Recognizer()
self.microphone = sr.Microphone()
self.callback = None
self.stop_thread = None
self.kill_yourself = False
self.audio_stream = None
# get global configuration
sl = SettingLoader()
self.settings = sl.settings
if audio_file is None:
# audio file not set, we need to capture a sample from the microphone
with self.microphone as source:
if self.settings.options.adjust_for_ambient_noise_second > 0:
# threshold is calculated from capturing ambient sound
logger.debug("[SpeechRecognition] threshold calculated by "
"capturing ambient noise during %s seconds" %
self.settings.options.adjust_for_ambient_noise_second)
Utils.print_info("[SpeechRecognition] capturing ambient sound during %s seconds" %
self.settings.options.adjust_for_ambient_noise_second)
self.recognizer.adjust_for_ambient_noise(source,
duration=self.settings.
options.adjust_for_ambient_noise_second)
else:
# threshold is defined manually
logger.debug("[SpeechRecognition] threshold defined by settings: %s" %
self.settings.options.energy_threshold)
self.recognizer.energy_threshold = self.settings.options.energy_threshold
Utils.print_info("[SpeechRecognition] Threshold set to: %s" % self.recognizer.energy_threshold)
else:
# audio file provided
with sr.AudioFile(audio_file) as source:
self.audio_stream = self.recognizer.record(source) # read the entire audio file
def AddToList(self, list, items):
my_list = None
processed_items = []
for l in self.keep.all():
if l.title.lower() == list.lower():
my_list = l
break
if not my_list:
Utils.print_info("List not available, create a new list")
my_list = self.keep.createList(list)
if self.pin_list:
my_list.pinned = True
else:
my_list.pinned = False
for item in items:
for i in my_list.items:
if i.text.lower() == item.lower():
i.checked = False
Utils.print_info("Item %s already in list" %
str(i).replace("☐ ", ""))
break
else:
my_list.add(item, False)
Utils.print_info("Add item %s to list" % item)
processed_items.append(item)
self.syncKeep()
return processed_items
def __init__(self,
keyword=None,
sensitivity=None,
detected_callback=None
):
super(HotwordDetector, self).__init__()
sl = SettingLoader()
self.settings = sl.settings
self.paused_loop = False
self.detected_callback = detected_callback
self.sensitivity = sensitivity
trigger_level = 3
self.keyword = keyword
self.found_keyword = False
if not os.path.exists(RESOURCE_FILE):
if self.downloadPreciseEngine():
Utils.print_info("[Precise] Download complete")
else:
raise PreciseEngineNotFound("Error downloading precise engine, check your internet connection or try again later.")
engine = PreciseEngine(RESOURCE_FILE, self.keyword)
self.stream = ReadWriteStream()
self.runner = PreciseRunner(engine,
sensitivity=float(self.sensitivity),
trigger_level=trigger_level,
on_activation=self.activation
)
self.runner.start()
self.pause() # To avoid that precise starts detecting without beeing ready, we pause it right after start
if self.settings.machine.startswith("arm"): # Because importing tensorflow takes up to 10 seconds, we sleep a while
Utils.print_info("Starting precise trigger")
time.sleep(10)
def __init__(self):
super(Order, self).__init__()
Utils.print_info('Starting order signal')
# load settings and brain from singleton
sl = SettingLoader()
self.settings = sl.settings
self.brain = BrainLoader().brain
# keep in memory the order to process
self.order_to_process = None
# get the player instance
self.player_instance = PlayerLauncher.get_player(
settings=self.settings)
# save an instance of the trigger
self.trigger_instance = None
self.trigger_callback_called = False
self.is_trigger_muted = False
# If kalliope is asked to start muted
if self.settings.start_options['muted'] is True:
self.is_trigger_muted = True
# save the current order listener
self.order_listener = None
self.order_listener_callback_called = False
# Initialize the state machine
self.machine = Machine(model=self,
states=Order.states,
initial='init',
queued=True)
# define transitions
self.machine.add_transition('start_trigger',
['init', 'analysing_order'],
'starting_trigger')
self.machine.add_transition('wait_trigger_callback',
'starting_trigger',
'waiting_for_trigger_callback')
self.machine.add_transition('stop_trigger',
'waiting_for_trigger_callback',
'stopping_trigger')
self.machine.add_transition('wait_for_order', 'stopping_trigger',
'waiting_for_order_listener_callback')
self.machine.add_transition('analyse_order',
'waiting_for_order_listener_callback',
'analysing_order')
self.machine.add_ordered_transitions()
# add method which are called when changing state
self.machine.on_enter_starting_trigger('start_trigger_process')
self.machine.on_enter_waiting_for_trigger_callback(
'waiting_for_trigger_callback_thread')
self.machine.on_enter_stopping_trigger('stop_trigger_process')
self.machine.on_enter_start_order_listener(
'start_order_listener_thread')
self.machine.on_enter_waiting_for_order_listener_callback(
'waiting_for_order_listener_callback_thread')
self.machine.on_enter_analysing_order('analysing_order_thread')
def run(self):
"""
Start the voice detector. For every `sleep_time` second it checks the
audio buffer for triggering keywords. If detected, then call
corresponding function in `detected_callback`, which can be a single
function (single model) or a list of callback functions (multiple
models). Every loop it also calls `interrupt_check` -- if it returns
True, then breaks from the loop and return.
:param detected_callback: a function or list of functions. The number of
items must match the number of models in
`decoder_model`.
:param interrupt_check: a function that returns True if the main loop
needs to stop.
:param float sleep_time: how much time in second every loop waits.
:param audio_recorder_callback: if specified, this will be called after
a keyword has been spoken and after the
phrase immediately after the keyword has
been recorded. The function will be
passed the name of the file where the
phrase was recorded.
:param silent_count_threshold: indicates how long silence must be heard
to mark the end of a phrase that is
being recorded.
:param recording_timeout: limits the maximum length of a recording.
:return: None
"""
if self.interrupt_check():
logger.debug("detect voice return")
return
tc = type(self.detected_callback)
if tc is not list:
self.detected_callback = [self.detected_callback]
if len(self.detected_callback) == 1 and self.num_hotwords > 1:
self.detected_callback *= self.num_hotwords
assert self.num_hotwords == len(self.detected_callback), \
"Error: hotwords in your models (%d) do not match the number of " \
"callbacks (%d)" % (self.num_hotwords, len(self.detected_callback))
logger.debug("detecting...")
SR = SpeechRecorder()
while not self.kill_received:
#if not self.paused:
if self.interrupt_check():
logger.debug("detect voice break")
break
data = self.ring_buffer.get()
if len(data) == 0:
time.sleep(self.sleep_time)
continue
self.saveMessage(
data
) # Save trigger data so it can be append to the record for STT
status = self.detector.RunDetection(data)
if status > 0: #key word found
SR.start() # Start the speech recorder
Utils.print_info("Keyword " + self.keyword_names[status] +
" detected")
Cortex.save(
'kalliope_trigger_called', self.keyword_names[status]
) # I save it to the Cortex, to use it by another neuron
# for changing the tts acording to the trigger name
HookManager.on_triggered()
callback = self.detected_callback[status - 1]
if callback is not None:
callback()
if status == -1:
logger.warning(
"Error initializing streams or reading audio data")
logger.debug("finished.")
def __init__(self, **kwargs):
super(Enigma, self).__init__(**kwargs)
# the args from the neuron configuration
self.ip = kwargs.get('ip', None)
self.port = kwargs.get('port', 80)
self.login = kwargs.get('login', None)
self.password = kwargs.get('passwort', None)
self.command = kwargs.get('command', None)
self.channel = kwargs.get('channel', None)
self.file = kwargs.get('file', None)
if self._is_parameters_ok():
path = Utils.get_real_file_path(self.file)
file = None
found = False
if self.login:
url = "http://" + self.login + ":" + self.password + "@" + str(
self.ip) + ":" + str(self.port)
else:
url = "http://" + str(self.ip) + ":" + str(self.port)
if self.channel:
url = url + "/web/zap?sRef="
file = open(path, "r")
channels = yaml.load(file)
for channel in channels:
if channel == self.channel:
Utils.print_info("Channel found: " + channel)
url = url + channels[channel]
found = True
break
if not found:
Utils.print_info("Channel : " + self.channel +
" not found")
else:
url = url + "/web/remotecontrol?command="
file = open(path, "r")
cmds = yaml.load(file)
for cmd in cmds:
if cmd == self.command:
Utils.print_info("Command found: " + cmd)
url = url + cmds[cmd]
found = True
break
if not found:
Utils.print_info("Command : " + self.command +
" not found")
if found:
Utils.print_info("Sending: " + url)
try:
requests.post(url)
except requests.exceptions.ConnectionError:
Utils.print_info("Failed to establish a new connection")
