def _fill_limiters(self):
for limiter in ('Analog Limiter', 'HDMI Limiter', 'SPDIF Limiter'):
try:
self._limiters[limiter] = Mixer(limiter)
except ALSAAudioError:
self._limiters[limiter] = Mixer(limiter, self._def_id, self._def_card)
return None
def __init__(self):
super(AlarmSkill, self).__init__()
self.beep_process = None
self.beep_start_time = None
self.flash_state = 0
# Seconds of gap between sound repeats.
# The value name must match an option from the 'sound' value of the
# settingmeta.json, which also corresponds to the name of an mp3
# file in the skill's sounds/ folder. E.g. <skill>/sounds/bell.mp3
#
self.sounds = {
"bell": 5.0,
"escalate": 32.0,
"constant_beep": 5.0,
"beep4": 4.0,
"chimes": 22.0
}
#initialize alarm settings
self.init_settings()
try:
self.mixer = Mixer()
except Exception:
# Retry instanciating the mixer
try:
self.mixer = Mixer()
except Exception as e:
self.log.error('Couldn\'t allocate mixer, {}'.format(repr(e)))
self.mixer = None
self.saved_volume = None
def _switch_gain_override(self):
try:
gain = Mixer('Gain Override')
gain.setmute(0)
except ALSAAudioError:
gain = Mixer('Gain Override', self._def_id, self._def_card)
gain.setmute(0)
return None
def __init__(self):
super(VolumeSkill, self).__init__("VolumeSkill")
self.default_level = self.config.get('default_level')
self.min_volume = self.config.get('min_volume')
self.max_volume = self.config.get('max_volume')
self.volume_sound = join(dirname(__file__), "blop-mark-diangelo.wav")
try:
self.mixer = Mixer("PCM")
except Exception:
# Retry instanciating the mixer
try:
self.mixer = Mixer()
except Exception as e:
self.log.error('Couldn\'t allocate mixer, {}'.format(repr(e)))
def process(self, data):
self.client.emit(Message(data))
if "mycroft.stop" in data:
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("wifisetup.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 initialize(self):
self.mute = str(self.settings.get('MuteIt', ''))
if (self.mute == 'True') or (self.mute == 'true'):
try:
self.mixer = Mixer()
msg = "Telegram Messages will temporary Mute Mycroft"
logger.info(msg)
except:
msg = "There is a problem with alsa audio, mute is not working!"
logger.info(
"There is a problem with alsaaudio, mute is not working!")
self.sendMycroftSay(msg)
self.mute = 'false'
else:
logger.info("Telegram: Muting is off")
self.mute = "false"
self.add_event('recognizer_loop:utterance', self.utteranceHandler)
self.add_event('telegram-skill:response', self.sendHandler)
self.add_event('speak', self.responseHandler)
user_id1 = self.settings.get('TeleID1', '')
self.chat_id = user_id1
self.chat_whitelist = [user_id1]
# Get Bot Token from settings.json
UnitName = DeviceApi().get()['name']
MyCroftDevice1 = self.settings.get('MDevice1', '')
self.bottoken = ""
if MyCroftDevice1 == UnitName:
logger.debug("Found MyCroft Unit 1: " + UnitName)
self.bottoken = self.settings.get('TeleToken1', '')
else:
msg = (
"No or incorrect Device Name specified! Your DeviceName is: " +
UnitName)
logger.info(msg)
self.sendMycroftSay(msg)
# Connection to Telegram API
self.telegram_updater = Updater(
token=self.bottoken) # get telegram Updates
self.telegram_dispatcher = self.telegram_updater.dispatcher
receive_handler = MessageHandler(
Filters.text, self.TelegramMessages
) # TODO: Make audio Files as Input possible: Filters.text | Filters.audio
self.telegram_dispatcher.add_handler(receive_handler)
self.telegram_updater.start_polling(
clean=True) # start clean and look for messages
wbot = telegram.Bot(token=self.bottoken)
global loaded # get global variable
if loaded == 0: # check if bot is just started
loaded = 1 # make sure that users gets this message only once bot is newly loaded
if self.mute == "false":
msg = "Telegram Skill is loaded"
self.sendMycroftSay(msg)
loadedmessage = "Telegram-Skill on Mycroft Unit \"" + UnitName + "\" is loaded and ready to use!" # give User a nice message
try:
wbot.send_message(
chat_id=user_id1,
text=loadedmessage) # send welcome message to user 1
except:
pass
def __init__(self, mplfifo, ser, mpout, beep=True):
self.playing = False
self.mixer = Mixer(control='PCM')
self.fifo = mplfifo
self.ser = ser
self.mpout = mpout
self.beep = beep
def __init__(self, player):
self.player = player
self._alsa_mixer = Mixer(control="PCM")
self.is_pressed = False
GPIO.setmode(GPIO.BOARD)
input_buttons = [k for k in self.buttons.keys()]
GPIO.setup(input_buttons, GPIO.IN, pull_up_down=GPIO.PUD_UP)
def process(self, data):
self.client.emit(Message(data))
if "mycroft.stop" in data:
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)
def action3(self):
sound = Mixer()
vol = sound.getvolume()[
0] # we can take either 0 or 1 it does not matter
vol -= self.step * self.amplifier
self.amplifier = 1 # reset the amplifier
sound.setvolume(vol)
os.system('notify-send "Volume down to %s"' % vol)
def set_hdmi_mute(self, mute):
try:
mix = Mixer('HDMI')
mix.setmute(mute)
log.debug('Set HDMI sound control to %s', mute)
return True
except ALSAAudioError, e:
log.error('Impossible to set HDMI sound mute to %s <%s>', mute, e)
return False
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 handle_decrease_volume(self, message):
level = Mixer().getvolume()[0]
# turn down the volume FAST if it's too loud!
if level >= 93:
self.__update_volume(-3)
elif level >= 86:
self.__update_volume(-2)
else:
self.__update_volume(-1)
def __update_volume(self, level=0):
mixer = Mixer()
volume = mixer.getvolume()[0]
code = self.get_volume_code(volume) + level
code = self.fix_code(code)
if code in self.VOLUMES:
volume = self.VOLUMES[code]
mixer.setvolume(volume)
return code, volume
def initialize(voice_command, sentences):
if system() == "Windows":
press('volumedown', presses=5)
else:
m = Mixer()
current_volume = m.getvolume() # Get the current Volume
m.setvolume(current_volume - 10) # Set the volume to -10%.
return True, ""
def __init__(self):
super(VolumeSkill, self).__init__("VolumeSkill")
self.default_level = self.config.get('default_level')
self.min_volume = self.config.get('min_volume')
self.max_volume = self.config.get('max_volume')
self.volume_sound = join(dirname(__file__), "blop-mark-diangelo.wav")
try:
Mixer()
except:
self.log.warning('HACK: first access to Mixer() error workaround')
def __init__(self):
super(VolumeSkill, self).__init__("VolumeSkill")
self.default_level = self.config.get('default_level')
self.min_volume = self.config.get('min_volume')
self.max_volume = self.config.get('max_volume')
self.volume_sound = join(dirname(__file__), "blop-mark-diangelo.wav")
try:
Mixer()
except:
LOGGER.warning('Weird first access to Mixer() error workaround ' +
'still triggering. This should be fixed properly.')
def action2(self):
sound = Mixer()
vol = sound.getvolume(
)[0] # we can take either 0 or 1 from what I gathered, it does not matter
vol += self.step * self.amplifier
self.amplifier = 1 # reset the amplifier
try:
sound.setvolume(vol)
os.system('notify-send "Volume up to %s"' % vol)
except Exception:
os.system('notify-send "Volume is already up to it\'s maximum"')
def __update_volume(self, change=0):
"""
Tries to change volume level
:param change: +1 or -1; the step to change by
:return: new code (0..11), whether volume changed
"""
mixer = Mixer()
old_level = self.volume_to_level(mixer.getvolume()[0])
new_level = self.bound_level(old_level + change)
self.enclosure.eyes_volume(new_level)
mixer.setvolume(self.level_to_volume(new_level))
return new_level, new_level != old_level
def notify(self, timestamp):
with self.LOCK:
if self.data.__contains__(timestamp):
volume = None
self.alarm_on = True
delay = self.__calculate_delay(self.max_delay)
while self.alarm_on and datetime.now() < delay:
play_mp3(self.file_path).communicate()
self.speak_dialog('alarm.stop')
time.sleep(self.repeat_time + 2)
if not volume and datetime.now() >= delay:
mixer = Mixer()
volume = mixer.getvolume()[0]
mixer.setvolume(100)
delay = self.__calculate_delay(self.extended_delay)
if volume:
Mixer().setvolume(volume)
self.remove(timestamp)
self.alarm_on = False
self.save()
def get_mixer(self, control="Master"):
if self._mixer is None:
try:
mixer = Mixer(control)
except Exception as e:
try:
mixer = Mixer(control)
except Exception as e:
try:
if control != "Master":
LOG.warning("could not allocate requested mixer, "
"falling back to 'Master'")
mixer = Mixer("Master")
else:
raise
except Exception as e:
LOG.error("Couldn't allocate mixer")
LOG.exception(e)
raise
self._mixer = mixer
return self.mixer
def _get_mixer(self):
self.log.debug('Finding Alsa Mixer for control...')
mixer = None
try:
# If there are only 1 mixer use that one
mixers = alsa_mixers()
if len(mixers) == 1:
mixer = Mixer(mixers[0])
elif 'Master' in mixers:
# Try using the default mixer (Master)
mixer = Mixer('Master')
elif 'PCM' in mixers:
# PCM is another common one
mixer = Mixer('PCM')
elif 'Digital' in mixers:
# My mixer is called 'Digital' (JustBoom DAC)
mixer = Mixer('Digital')
else:
# should be equivalent to 'Master'
mixer = Mixer()
except Exception:
# Retry instanciating the mixer with the built-in default
try:
mixer = Mixer()
except Exception as e:
self.log.error('Couldn\'t allocate mixer, {}'.format(repr(e)))
self._mixer = mixer
return mixer
def notify(self, timestamp):
with self.LOCK:
if self.data.__contains__(timestamp):
volume = None
self.reminder_on = True
delay = self.__calculate_delay(self.max_delay)
while self.reminder_on and datetime.now() < delay:
self.speak_dialog('reminder.notify', data=self.build_feedback_payload(timestamp))
time.sleep(1)
self.speak_dialog('reminder.stop')
time.sleep(self.repeat_time)
if not volume and datetime.now() >= delay:
mixer = Mixer()
volume = mixer.getvolume()[0]
mixer.setvolume(100)
delay = self.__calculate_delay(self.extended_delay)
if volume:
Mixer().setvolume(volume)
self.remove(timestamp)
self.reminder_on = False
self.save()
def set_volume(request, username, value):
global volume_who, volume_direction
m = Mixer()
if value > m.getvolume()[0]:
volume_direction = "up"
volume_who = username
elif value < m.getvolume()[0]:
volume_direction = "down"
else:
return volume() # no change, quit
volume_who = username
m.setvolume(value)
return volume()
def on_settings_changed(self):
global speak_tele
speak_tele = 0
self.telegram_updater = None
self.mute = str(self.settings.get('MuteIt',''))
if (self.mute == 'True') or (self.mute == 'true'):
try:
self.mixer = Mixer()
msg = "Telegram Messages will temporary mute Mycroft"
logger.info(msg)
except:
global audioinit
if audioinit == 0:
audioinit = 1
msg = "There is a problem with alsa audio, mute is not working!"
self.sendMycroftSay(msg)
logger.info("There is a problem with alsaaudio, mute is not working!")
self.mute = 'false'
else:
logger.info("Telegram: Muting is off")
self.mute = "false"
try:
# Get Bot Token from settings.json
self.UnitName = DeviceApi().get()['name']
MyCroftDevice1 = self.settings.get('MDevice1','')
MyCroftDevice2 = self.settings.get('MDevice2','')
except:
pass
try:
self.bottoken = ""
if MyCroftDevice1 == self.UnitName:
logger.debug("Found MyCroft Unit 1: " + self.UnitName)
self.bottoken = self.settings.get('TeleToken1', '')
elif MyCroftDevice2 == self.UnitName:
logger.debug("Found MyCroft Unit 2: " + self.UnitName)
self.bottoken = self.settings.get('TeleToken2', '')
else:
msg = ("No or incorrect Device Name specified! Your DeviceName is: " + self.UnitName)
logger.info(msg)
self.sendMycroftSay(msg)
except:
pass
try:
self.user_id1 = self.settings.get('TeleID1', '')
self.user_id2 = self.settings.get('TeleID2', '')
self.chat_whitelist = [self.user_id1,self.user_id2]
except:
pass
def __update_volume(self, level=0):
"""
Tries to change volume level
:param level: +1 or -1; the step to change by
:return: new code (0..11), whether volume changed
"""
mixer = Mixer()
volume = mixer.getvolume()[0]
old_code = self.get_volume_code(volume)
new_code = self.fix_code(old_code + level)
if new_code in self.VOLUMES:
volume = self.VOLUMES[new_code]
mixer.setvolume(volume)
return new_code, new_code != old_code
def __init_alsa(self):
try:
self._device = PCM()
except ALSAAudioError as e:
logger.error('ERROR: Error al inicializar dispositivo ALSA: %s' %
str(e))
return
else:
for mixer in MIXER_PRIO:
try:
self._mixers[mixer] = Mixer(mixer)
except ALSAAudioError as e:
err = 'Warning: Error al inicializar mixer ALSA: %s'
logger.warning(err % str(e))
else:
if self._default_mixer is None:
self._default_mixer = mixer
def __update_volume(self, change=0):
"""
Attempt to change audio level
Args:
change (int): +1 or -1; the step to change by
Returns:
int: new level code (0..11)
bool: whether level changed
"""
mixer = Mixer()
old_level = self.__volume_to_level(mixer.getvolume()[0])
new_level = self.__bound_level(old_level + change)
self.enclosure.eyes_volume(new_level)
mixer.setvolume(self.__level_to_volume(new_level))
return new_level, new_level != old_level
def read_alsa_data(self):
from alsaaudio import Mixer
volumes = Mixer(self.mixername).getvolume()
channels = 0
vol = 0
for i in range(len(volumes)):
channels += 1
vol += volumes[i]
if channels > 0:
vol = round(vol / channels)
if vol != self.alsavol:
logging.debug("ALSA volume changed from {}% to {}%".format(
self.alsavol, vol))
self.alsavol = vol
return True
else:
return False
def initialize(self):
self.filename = os.path.join(get_ipc_directory(), "mic_level")
self.audio_service = AudioService(self.bus)
self.mixer = Mixer()
self.schedule_repeating_event(self.auto_set_volume, None, 5,
'AutoVolume')
self.schedule_repeating_event(self.mesure_mic_thresh, None, 1,
'AutoVolume_messure')
self.autovolume = True
if self.settings.get('High volume') is None:
self.settings['High volume'] = 75
if self.settings.get('Normal volume') is None:
self.settings['Normal volume'] = 60
if self.settings.get('Low volume') is None:
self.settings['Low volume'] = 35
self.add_event('recognizer_loop:record_begin',
self.handle_listener_started)
self.add_event('recognizer_loop:record_end',
self.handle_listener_ended)
wait_while_speaking()
with io.open(self.filename, 'r') as fh:
while True:
line = fh.readline()
if line == "":
break
# Ex:Energy: cur=4 thresh=1.5
parts = line.split("=")
meter_thresh = float(parts[-1])
if self.settings.get('Highest messurement') is None:
self.settings['Highest messurement'] = meter_thresh
if self.settings.get('Lowest messurement') is None:
self.settings['Lowest messurement'] = meter_thresh
self.volume = int(self.settings.get('Low volume'))
self.meter_thresh = 0
self.meter_high = meter_thresh
self.meter_low = meter_thresh
self.meter_thresh_list = []
self.meter_thresh_list.append(meter_thresh)
