def main():
rospy.init_node('mycroft_message_bus')
rospy.loginfo(rospy.get_caller_id() + " started")
import tornado.options
reset_sigint_handler()
lock = Lock("service")
tornado.options.parse_command_line()
def reload_hook():
""" Hook to release lock when autoreload is triggered. """
lock.delete()
autoreload.add_reload_hook(reload_hook)
config = Configuration.get().get("websocket")
host = config.get("host")
port = config.get("port")
route = config.get("route")
validate_param(host, "websocket.host")
validate_param(port, "websocket.port")
validate_param(route, "websocket.route")
routes = [(route, WebsocketEventHandler)]
application = web.Application(routes, **settings)
application.listen(port, host)
create_daemon(ioloop.IOLoop.instance().start)
wait_for_exit_signal()
rospy.spin()
def main(ready_hook=on_ready, error_hook=on_error, stopping_hook=on_stopping):
""" Main function. Run when file is invoked. """
try:
reset_sigint_handler()
check_for_signal("isSpeaking")
bus = MessageBusClient() # Connect to the Mycroft Messagebus
Configuration.set_config_update_handlers(bus)
speech.init(bus)
LOG.info("Starting Audio Services")
bus.on('message',
create_echo_function('AUDIO', ['mycroft.audio.service']))
# Connect audio service instance to message bus
audio = AudioService(bus)
except Exception as e:
error_hook(e)
else:
create_daemon(bus.run_forever)
if audio.wait_for_load() and len(audio.service) > 0:
# If at least one service exists, report ready
ready_hook()
wait_for_exit_signal()
stopping_hook()
else:
error_hook('No audio services loaded')
speech.shutdown()
audio.shutdown()
def main():
import tornado.options
reset_sigint_handler()
lock = Lock("service")
tornado.options.parse_command_line()
def reload_hook():
""" Hook to release lock when autoreload is triggered. """
lock.delete()
autoreload.add_reload_hook(reload_hook)
config = Configuration.get().get("websocket")
host = config.get("host")
port = config.get("port")
route = config.get("route")
validate_param(host, "websocket.host")
validate_param(port, "websocket.port")
validate_param(route, "websocket.route")
routes = [
(route, WebsocketEventHandler)
]
application = web.Application(routes, **settings)
application.listen(port, host)
create_daemon(ioloop.IOLoop.instance().start)
wait_for_exit_signal()
def listener():
rospy.init_node('mycroft_skills')
rospy.loginfo(rospy.get_caller_id() + " started")
rospy.Subscriber("mycroft/utterance", String, handle_utterance)
rospy.Subscriber("mycroft/remove_skill", String, handle_remove_skill)
s = rospy.Service('mycroft/register_skill', MycroftService,
handle_register_skill)
global bus
reset_sigint_handler()
# Create PID file, prevent multiple instancesof this service
mycroft.lock.Lock('skills')
# Connect this Skill management process to the Mycroft Messagebus
bus = WebsocketClient()
Configuration.init(bus)
config = Configuration.get()
# Set the active lang to match the configured one
set_active_lang(config.get('lang', 'en-us'))
bus.on('skill.manager.initialised', initialise_response_server)
bus.on('message', create_echo_function('SKILLS'))
# Startup will be called after the connection with the Messagebus is done
bus.once('open', _starting_up)
bus.on('skill.converse.request', check_working)
create_daemon(bus.run_forever)
wait_for_exit_signal()
shutdown()
rospy.spin()
def main(ready_hook=on_ready, error_hook=on_error, stopping_hook=on_stopping):
# Read the system configuration
"""Launch one of the available enclosure implementations.
This depends on the configured platform and can currently either be
mycroft_mark_1 or mycroft_mark_2, if unconfigured a generic enclosure with
only the GUI bus will be started.
"""
# Read the system configuration
system_config = LocalConf(SYSTEM_CONFIG)
platform = system_config.get("enclosure", {}).get("platform")
enclosure = create_enclosure(platform)
if enclosure:
try:
LOG.debug("Enclosure started!")
reset_sigint_handler()
create_daemon(enclosure.run)
ready_hook()
wait_for_exit_signal()
stopping_hook()
except Exception as e:
print(e)
else:
LOG.info("No enclosure available for this hardware, running headless")
def main():
reset_sigint_handler()
# Create PID file, prevent multiple instances of this service
mycroft.lock.Lock('skills')
config = Configuration.get()
# Set the active lang to match the configured one
set_active_lang(config.get('lang', 'en-us'))
# Connect this process to the Mycroft message bus
bus = _start_message_bus_client()
_register_intent_services(bus)
event_scheduler = EventScheduler(bus)
skill_manager = _initialize_skill_manager(bus)
_wait_for_internet_connection()
if skill_manager is None:
skill_manager = _initialize_skill_manager(bus)
device_primer = DevicePrimer(bus, config)
device_primer.prepare_device()
skill_manager.start()
wait_for_exit_signal()
shutdown(skill_manager, event_scheduler)
def main(ready_hook=on_ready, error_hook=on_error, stopping_hook=on_stopping,
watchdog=None):
reset_sigint_handler()
# Create PID file, prevent multiple instances of this service
mycroft.lock.Lock('skills')
config = Configuration.get()
# Set the active lang to match the configured one
set_active_lang(config.get('lang', 'en-us'))
# Connect this process to the Mycroft message bus
bus = _start_message_bus_client()
_register_intent_services(bus)
event_scheduler = EventScheduler(bus)
skill_manager = _initialize_skill_manager(bus, watchdog)
_wait_for_internet_connection()
if skill_manager is None:
skill_manager = _initialize_skill_manager(bus, watchdog)
device_primer = DevicePrimer(bus, config)
device_primer.prepare_device()
skill_manager.start()
while not skill_manager.is_alive():
time.sleep(0.1)
ready_hook() # Report ready status
wait_for_exit_signal()
stopping_hook() # Report shutdown started
shutdown(skill_manager, event_scheduler)
def main(ready_hook=on_ready,
error_hook=on_error,
stopping_hook=on_stopping,
watchdog=lambda: None):
global bus
global loop
global config
try:
reset_sigint_handler()
PIDLock("voice")
config = Configuration.get()
bus = start_message_bus_client("VOICE")
connect_bus_events(bus)
callbacks = StatusCallbackMap(on_ready=ready_hook,
on_error=error_hook,
on_stopping=stopping_hook)
status = ProcessStatus('speech', bus, callbacks)
# Register handlers on internal RecognizerLoop bus
loop = RecognizerLoop(watchdog)
connect_loop_events(loop)
create_daemon(loop.run)
status.set_started()
except Exception as e:
error_hook(e)
else:
status.set_ready()
wait_for_exit_signal()
status.set_stopping()
def main():
global ws
global loop
reset_sigint_handler()
PIDLock("voice")
ws = WebsocketClient()
Configuration.init(ws)
loop = RecognizerLoop()
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:speech.recognition.unknown', handle_unknown)
loop.on('speak', handle_speak)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:awoken', handle_awoken)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('recognizer_loop:no_internet', handle_no_internet)
ws.on('open', handle_open)
ws.on('complete_intent_failure', handle_complete_intent_failure)
ws.on('recognizer_loop:sleep', handle_sleep)
ws.on('recognizer_loop:wake_up', handle_wake_up)
ws.on('mycroft.mic.mute', handle_mic_mute)
ws.on('mycroft.mic.unmute', handle_mic_unmute)
ws.on('mycroft.mic.get_status', handle_mic_get_status)
ws.on("mycroft.paired", handle_paired)
ws.on('recognizer_loop:audio_output_start', handle_audio_start)
ws.on('recognizer_loop:audio_output_end', handle_audio_end)
ws.on('mycroft.stop', handle_stop)
create_daemon(ws.run_forever)
create_daemon(loop.run)
wait_for_exit_signal()
def main(ready_hook=on_ready, error_hook=on_error, stopping_hook=on_stopping):
"""Start the Audio Service and connect to the Message Bus"""
LOG.info("Starting Audio Service")
try:
reset_sigint_handler()
check_for_signal("isSpeaking")
whitelist = ['mycroft.audio.service']
bus = start_message_bus_client("AUDIO", whitelist=whitelist)
callbacks = StatusCallbackMap(on_ready=ready_hook,
on_error=error_hook,
on_stopping=stopping_hook)
status = ProcessStatus('audio', bus, callbacks)
speech.init(bus)
# Connect audio service instance to message bus
audio = AudioService(bus)
status.set_started()
except Exception as e:
status.set_error(e)
else:
if audio.wait_for_load() and len(audio.service) > 0:
# If at least one service exists, report ready
status.set_ready()
wait_for_exit_signal()
status.set_stopping()
else:
status.set_error('No audio services loaded')
speech.shutdown()
audio.shutdown()
def main():
global ws
ws = WebsocketClient()
Configuration.init(ws)
create_daemon(ws.run_forever)
if proximity_enabled:
BT_Scanner()
wait_for_exit_signal()
def main(alive_hook=on_alive,
started_hook=on_started,
ready_hook=on_ready,
error_hook=on_error,
stopping_hook=on_stopping,
watchdog=None):
reset_sigint_handler()
# Create PID file, prevent multiple instances of this service
mycroft.lock.Lock('skills')
config = Configuration.get()
# Set the active lang to match the configured one
set_default_lang(config.get('lang', 'en-us'))
# Set the default timezone to match the configured one
set_default_tz()
# Connect this process to the Mycroft message bus
bus = start_message_bus_client("SKILLS")
_register_intent_services(bus)
event_scheduler = EventScheduler(bus)
callbacks = StatusCallbackMap(on_started=started_hook,
on_alive=alive_hook,
on_ready=ready_hook,
on_error=error_hook,
on_stopping=stopping_hook)
status = ProcessStatus('skills', bus, callbacks)
SkillApi.connect_bus(bus)
skill_manager = _initialize_skill_manager(bus, watchdog)
status.set_started()
_wait_for_internet_connection()
if skill_manager is None:
skill_manager = _initialize_skill_manager(bus, watchdog)
device_primer = DevicePrimer(bus, config)
device_primer.prepare_device()
skill_manager.start()
while not skill_manager.is_alive():
time.sleep(0.1)
status.set_alive()
while not skill_manager.is_all_loaded():
time.sleep(0.1)
status.set_ready()
wait_for_exit_signal()
status.set_stopping()
shutdown(skill_manager, event_scheduler)
def main():
""" Main function. Run when file is invoked. """
reset_sigint_handler()
ws = WebsocketClient()
Configuration.init(ws)
speech.init(ws)
LOG.info("Starting Audio Services")
ws.on('message', create_echo_function('AUDIO', ['mycroft.audio.service']))
audio = AudioService(ws) # Connect audio service instance to message bus
create_daemon(ws.run_forever)
wait_for_exit_signal()
speech.shutdown()
audio.shutdown()
def main():
global bus
reset_sigint_handler()
# Create PID file, prevent multiple instancesof this service
mycroft.lock.Lock('skills')
# Connect this Skill management process to the Mycroft Messagebus
bus = WebsocketClient()
Configuration.init(bus)
bus.on('message', create_echo_function('SKILLS'))
# Startup will be called after the connection with the Messagebus is done
bus.once('open', _starting_up)
create_daemon(bus.run_forever)
wait_for_exit_signal()
shutdown()
def main():
global bus
reset_sigint_handler()
# Create PID file, prevent multiple instancesof this service
mycroft.lock.Lock('skills')
# Connect this Skill management process to the Mycroft Messagebus
bus = WebsocketClient()
Configuration.init(bus)
bus.on('message', create_echo_function('SKILLS'))
# Startup will be called after the connection with the Messagebus is done
bus.once('open', _starting_up)
create_daemon(bus.run_forever)
wait_for_exit_signal()
shutdown()
def main():
""" Main function. Run when file is invoked. """
reset_sigint_handler()
check_for_signal("isSpeaking")
bus = WebsocketClient() # Connect to the Mycroft Messagebus
Configuration.init(bus)
speech.init(bus)
LOG.info("Starting Audio Services")
bus.on('message', create_echo_function('AUDIO', ['mycroft.audio.service']))
audio = AudioService(bus) # Connect audio service instance to message bus
create_daemon(bus.run_forever)
wait_for_exit_signal()
speech.shutdown()
audio.shutdown()
def main():
""" Main function. Run when file is invoked. """
reset_sigint_handler()
check_for_signal("isSpeaking")
bus = MessageBusClient() # Connect to the Mycroft Messagebus
Configuration.set_config_update_handlers(bus)
speech.init(bus)
LOG.info("Starting Audio Services")
bus.on('message', create_echo_function('AUDIO', ['mycroft.audio.service']))
audio = AudioService(bus) # Connect audio service instance to message bus
create_daemon(bus.run_forever)
wait_for_exit_signal()
speech.shutdown()
audio.shutdown()
def main():
import tornado.options
LOG.info('Starting message bus service...')
reset_sigint_handler()
lock = Lock("service")
# Disable all tornado logging so mycroft loglevel isn't overridden
tornado.options.parse_command_line(sys.argv + ['--logging=None'])
def reload_hook():
""" Hook to release lock when auto reload is triggered. """
lock.delete()
autoreload.add_reload_hook(reload_hook)
config = load_message_bus_config()
routes = [(config.route, MessageBusEventHandler)]
application = web.Application(routes, debug=True)
application.listen(config.port, config.host)
create_daemon(ioloop.IOLoop.instance().start)
LOG.info('Message bus service started!')
wait_for_exit_signal()
def main():
rospy.init_node('mycroft_stt')
rospy.loginfo(rospy.get_caller_id() + " started")
global bus
global loop
global config
reset_sigint_handler()
PIDLock("voice")
bus = WebsocketClient() # Mycroft messagebus, see mycroft.messagebus
Configuration.init(bus)
config = Configuration.get()
# Register handlers on internal RecognizerLoop bus
loop = RecognizerLoop()
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:speech.recognition.unknown', handle_unknown)
loop.on('speak', handle_speak)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:awoken', handle_awoken)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('recognizer_loop:no_internet', handle_no_internet)
# Register handlers for events on main Mycroft messagebus
bus.on('open', handle_open)
bus.on('complete_intent_failure', handle_complete_intent_failure)
bus.on('recognizer_loop:sleep', handle_sleep)
bus.on('recognizer_loop:wake_up', handle_wake_up)
bus.on('mycroft.mic.mute', handle_mic_mute)
bus.on('mycroft.mic.unmute', handle_mic_unmute)
bus.on('mycroft.mic.get_status', handle_mic_get_status)
bus.on("mycroft.paired", handle_paired)
bus.on('recognizer_loop:audio_output_start', handle_audio_start)
bus.on('recognizer_loop:audio_output_end', handle_audio_end)
bus.on('mycroft.stop', handle_stop)
create_daemon(bus.run_forever)
create_daemon(loop.run)
wait_for_exit_signal()
rospy.spin()
def main():
global bus
global loop
global config
reset_sigint_handler()
PIDLock("voice")
bus = WebsocketClient() # Mycroft messagebus, see mycroft.messagebus
Configuration.init(bus)
config = Configuration.get()
# Register handlers on internal RecognizerLoop bus
loop = RecognizerLoop()
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:speech.recognition.unknown', handle_unknown)
loop.on('speak', handle_speak)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:awoken', handle_awoken)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('recognizer_loop:no_internet', handle_no_internet)
# Register handlers for events on main Mycroft messagebus
bus.on('open', handle_open)
bus.on('complete_intent_failure', handle_complete_intent_failure)
bus.on('recognizer_loop:sleep', handle_sleep)
bus.on('recognizer_loop:wake_up', handle_wake_up)
bus.on('mycroft.mic.mute', handle_mic_mute)
bus.on('mycroft.mic.unmute', handle_mic_unmute)
bus.on('mycroft.mic.get_status', handle_mic_get_status)
bus.on("mycroft.paired", handle_paired)
bus.on('recognizer_loop:audio_output_start', handle_audio_start)
bus.on('recognizer_loop:audio_output_end', handle_audio_end)
bus.on('mycroft.stop', handle_stop)
create_daemon(bus.run_forever)
create_daemon(loop.run)
wait_for_exit_signal()
def main(ready_hook=on_ready, error_hook=on_error, stopping_hook=on_stopping,
watchdog=lambda: None):
global bus
global loop
global config
try:
reset_sigint_handler()
PIDLock("voice")
bus = MessageBusClient() # Mycroft messagebus, see mycroft.messagebus
Configuration.set_config_update_handlers(bus)
config = Configuration.get()
# Register handlers on internal RecognizerLoop bus
loop = RecognizerLoop(watchdog)
connect_loop_events(loop)
connect_bus_events(bus)
create_daemon(bus.run_forever)
create_daemon(loop.run)
except Exception as e:
error_hook(e)
else:
ready_hook()
wait_for_exit_signal()
stopping_hook()
def main():
rospy.init_node('mycroft_tts')
rospy.loginfo(rospy.get_caller_id() + " started")
rospy.Subscriber("mycroft/speak", String, handle_speak)
rospy.Subscriber("mycroft/stop", String, handle_stop)
""" Main function. Run when file is invoked. """
global bus
reset_sigint_handler()
check_for_signal("isSpeaking")
bus = WebsocketClient() # Connect to the Mycroft Messagebus
Configuration.init(bus)
speech.init(bus)
LOG.info("Starting Audio Services")
bus.on('message', create_echo_function('AUDIO', ['mycroft.audio.service']))
audio = AudioService(bus) # Connect audio service instance to message bus
create_daemon(bus.run_forever)
wait_for_exit_signal()
speech.shutdown()
audio.shutdown()
# keep node running
rospy.spin()