def on_no_internet(self, event=None):
if connected():
# One last check to see if connection was established
return
if time.time() - Enclosure._last_internet_notification < 30:
# don't bother the user with multiple notifications with 30 secs
return
Enclosure._last_internet_notification = time.time()
# TODO: This should go into EnclosureMark1 subclass of Enclosure.
if has_been_paired():
# Handle the translation within that code.
self.bus.emit(
Message(
"speak", {
'utterance':
"This device is not connected to the Internet. "
"Either plug in a network cable or set up your "
"wifi connection."
}))
else:
# enter wifi-setup mode automatically
self.bus.emit(Message('system.wifi.setup', {'lang': self.lang}))
def _do_net_check(self):
# TODO: This should live in the derived Enclosure, e.g. EnclosureMark1
LOG.info("Checking internet connection")
if not connected(): # and self.conn_monitor is None:
if has_been_paired():
# TODO: Enclosure/localization
self.speak("This unit is not connected to the Internet. "
"Either plug in a network cable or setup your "
"wifi connection.")
else:
# Begin the unit startup process, this is the first time it
# is being run with factory defaults.
# TODO: This logic should be in EnclosureMark1
# TODO: Enclosure/localization
# Don't listen to mic during this out-of-box experience
self.bus.emit(Message("mycroft.mic.mute"))
# Setup handler to unmute mic at the end of on boarding
# i.e. after pairing is complete
self.bus.once('mycroft.paired', self._handle_pairing_complete)
self.speak(mycroft.dialog.get('mycroft.intro'))
wait_while_speaking()
time.sleep(2) # a pause sounds better than just jumping in
# Kick off wifi-setup automatically
data = {'allow_timeout': False, 'lang': self.lang}
self.bus.emit(Message('system.wifi.setup', data))
def on_no_internet(self, event=None):
if connected():
# One last check to see if connection was established
return
if time.time() - Enclosure._last_internet_notification < 30:
# don't bother the user with multiple notifications with 30 secs
return
Enclosure._last_internet_notification = time.time()
# TODO: This should go into EnclosureMark1 subclass of Enclosure.
if has_been_paired():
# Handle the translation within that code.
self.ws.emit(
Message(
"speak", {
'utterance':
"This device is not connected to the Internet. "
"Either plug in a network cable or hold the "
"button on top for two seconds, then select "
"wifi from the menu"
}))
else:
# enter wifi-setup mode automatically
self.ws.emit(Message("mycroft.wifi.start"))
def _do_net_check(self):
# TODO: This should live in the derived Enclosure, e.g. Enclosure_Mark1
LOG.info("Checking internet connection")
if not connected(): # and self.conn_monitor is None:
if has_been_paired():
# TODO: Enclosure/localization
self.speak("This unit is not connected to the Internet. "
"Either plug in a network cable or hold the "
"button on top for two seconds, then select "
"wifi from the menu")
else:
# Begin the unit startup process, this is the first time it
# is being run with factory defaults.
# TODO: This logic should be in Enclosure_Mark1
# TODO: Enclosure/localization
# Don't listen to mic during this out-of-box experience
self.ws.emit(Message("mycroft.mic.mute"))
# Setup handler to unmute mic at the end of on boarding
# i.e. after pairing is complete
self.ws.once('mycroft.paired', self._handle_pairing_complete)
self.speak(mycroft.dialog.get('mycroft.intro'))
wait_while_speaking()
time.sleep(2) # a pause sounds better than just jumping in
# Kick off wifi-setup automatically
data = {'allow_timeout': False, 'lang': self.lang}
self.ws.emit(Message('system.wifi.setup', data))
def _do_net_check(self):
# TODO: This should live in the derived Enclosure, e.g. Enclosure_Mark1
LOG.info("Checking internet connection")
if not connected(): # and self.conn_monitor is None:
if has_been_paired():
# TODO: Enclosure/localization
self.ws.emit(Message("speak", {
'utterance': "This unit is not connected to the Internet."
" Either plug in a network cable or hold the "
"button on top for two seconds, then select "
"wifi from the menu"
}))
else:
# Begin the unit startup process, this is the first time it
# is being run with factory defaults.
# TODO: This logic should be in Enclosure_Mark1
# TODO: Enclosure/localization
# Don't listen to mic during this out-of-box experience
self.ws.emit(Message("mycroft.mic.mute", None))
# Kick off wifi-setup automatically
self.ws.emit(Message("mycroft.wifi.start",
{'msg': "Hello I am Mycroft, your new "
"assistant. To assist you I need to be "
"connected to the internet. You can "
"either plug me in with a network cable,"
" or use wifi. To setup wifi ",
'allow_timeout': False}))
def _do_net_check(self):
# TODO: This should live in the derived Enclosure, e.g. Enclosure_Mark1
LOG.info("Checking internet connection")
if not connected(): # and self.conn_monitor is None:
if has_been_paired():
# TODO: Enclosure/localization
self.ws.emit(Message("speak", {
'utterance': "This unit is not connected to the Internet."
" Either plug in a network cable or hold the "
"button on top for two seconds, then select "
"wifi from the menu"
}))
else:
# Begin the unit startup process, this is the first time it
# is being run with factory defaults.
# TODO: This logic should be in Enclosure_Mark1
# TODO: Enclosure/localization
# Don't listen to mic during this out-of-box experience
self.ws.emit(Message("mycroft.mic.mute", None))
# Kick off wifi-setup automatically
self.ws.emit(Message("mycroft.wifi.start",
{'msg': "Hello I am Mycroft, your new "
"assistant. To assist you I need to be "
"connected to the internet. You can "
"either plug me in with a network cable,"
" or use wifi. To setup wifi ",
'allow_timeout': False}))
def _do_net_check(self):
# TODO: This should live in the derived Enclosure, e.g. Enclosure_Mark1
LOG.info("Checking internet connection")
if not connected(): # and self.conn_monitor is None:
if has_been_paired():
# TODO: Enclosure/localization
self.ws.emit(
Message(
"speak", {
'utterance':
"This unit is not connected to the Internet."
" Either plug in a network cable or hold the "
"button on top for two seconds, then select "
"wifi from the menu"
}))
else:
# Begin the unit startup process, this is the first time it
# is being run with factory defaults.
# TODO: This logic should be in Enclosure_Mark1
# TODO: Enclosure/localization
# Don't listen to mic during this out-of-box experience
self.ws.emit(Message("mycroft.mic.mute"))
# Setup handler to unmute mic at the end of on boarding
# i.e. after pairing is complete
self.ws.once('mycroft.paired', self._handle_pairing_complete)
self.speak(mycroft.dialog.get('mycroft.intro'))
# Kick off wifi-setup automatically
data = {'allow_timeout': False, 'lang': self.lang}
self.ws.emit(Message('mycroft.wifi.start', data))
def on_no_internet(self, event=None):
if connected():
# One last check to see if connection was established
return
if time.time() - Enclosure._last_internet_notification < 30:
# don't bother the user with multiple notifications with 30 secs
return
Enclosure._last_internet_notification = time.time()
# TODO: This should go into EnclosureMark1 subclass of Enclosure.
if has_been_paired():
# Handle the translation within that code.
self.bus.emit(Message("speak", {
'utterance': "This device is not connected to the Internet. "
"Either plug in a network cable or set up your "
"wifi connection."}))
else:
# enter wifi-setup mode automatically
self.bus.emit(Message('system.wifi.setup', {'lang': self.lang}))
def on_no_internet(self, event=None):
if connected():
# One last check to see if connection was established
return
if time.time()-Enclosure._last_internet_notification < 30:
# don't bother the user with multiple notifications with 30 secs
return
Enclosure._last_internet_notification = time.time()
# TODO: This should go into EnclosureMark1 subclass of Enclosure.
if has_been_paired():
# Handle the translation within that code.
self.ws.emit(Message("speak", {
'utterance': "This device is not connected to the Internet. "
"Either plug in a network cable or hold the "
"button on top for two seconds, then select "
"wifi from the menu"}))
else:
# enter wifi-setup mode automatically
self.ws.emit(Message("mycroft.wifi.start"))
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 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 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):
# 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")}))
