def initDetector(self):
if self.detector is not None:
self.detector.terminate()
models = [
constants.getHotwordModel(config.get('hotword', 'xiaofeng.pmdl'))
]
# gql 检测唤醒词
self.detector = snowboydecoder.HotwordDetector(models,
sensitivity=config.get(
'sensitivity', 0.5))
# main loop
try:
callbacks = self._detected_callback
self.detector.start(
detected_callback=callbacks,
audio_recorder_callback=self._conversation.converse,
interrupt_check=self._interrupt_callback,
silent_count_threshold=config.get('silent_threshold', 15),
recording_timeout=config.get('recording_timeout', 5) * 4,
sleep_time=0.03)
self.detector.terminate()
except Exception as e:
print("error")
logger.critical('离线唤醒机制初始化失败：{}'.format(e))
def initDetector(self):
"""初始化唤醒探测器"""
if self.detector is not None:
self.detector.terminate()
models = [
constants.getHotwordModel(config.get('hotword', 'wukong.pmdl')),
constants.getHotwordModel(utils.get_do_not_bother_on_hotword()),
constants.getHotwordModel(utils.get_do_not_bother_off_hotword())
]
#唤醒词检测函数，调整sensitivity参数可修改唤醒词检测的准确性
self.detector = snowboydecoder.HotwordDetector(models,
sensitivity=config.get(
'sensitivity', 0.5))
# main loop
try:
#唤醒参数设置及成功唤醒后的回调设置
self.detector.start(
detected_callback=[
self._detected_callback, self._do_not_bother_on_callback,
self._do_not_bother_off_callback
],
audio_recorder_callback=self._conversation.converse,
interrupt_check=self._interrupt_callback,
silent_count_threshold=config.get('silent_threshold', 15),
recording_timeout=config.get('recording_timeout', 5) * 4,
sleep_time=0.03)
#释放资源
self.detector.terminate()
except Exception as e:
logger.critical('离线唤醒机制初始化失败：{}'.format(e))
def __init__(self):
self.interrupted = False
# 读取配置
config_file = 'config.yaml'
if os.path.exists(config_file) == False:
print('【警告】配置文件不存在')
return
f = open('config.yaml')
config = yaml.load(f)
model_name = config.get('name', 'snowboy')
if ['snowboy','alexa'].count(model_name) > 0:
model_name = model_name + '.umdl'
else:
model_name = model_name + '.pmdl'
self.model = "唤醒词/" + model_name # 使用的语音模型
print('【唤醒词文件】' + self.model)
if os.path.exists(self.model) == False:
print('【警告】唤醒词文件不存在')
return
signal.signal(signal.SIGINT, self.signal_handler) # 捕获ctrl+c
self.detector = snowboydecoder.HotwordDetector(self.model, sensitivity=0.5) # 设置语音模型与敏感度
print('Listening... Press Ctrl+Z to exit')
self.robot = Robot(config) # 创建应用模块
self.player = Player() # 触发响应词叮咚播放
def initDetector(self):
if self.detector is not None:
self.detector.terminate()
if config.get('/do_not_bother/hotword_switch', False):
models = [
constants.getHotwordModel(config.get('hotword', 'wukong.pmdl')),
constants.getHotwordModel(utils.get_do_not_bother_on_hotword()),
constants.getHotwordModel(utils.get_do_not_bother_off_hotword())
]
else:
models = constants.getHotwordModel(config.get('hotword', 'wukong.pmdl'))
self.detector = snowboydecoder.HotwordDetector(models, sensitivity=config.get('sensitivity', 0.5))
# main loop
try:
if config.get('/do_not_bother/hotword_switch', False):
callbacks = [self._detected_callback,
self._do_not_bother_on_callback,
self._do_not_bother_off_callback]
else:
callbacks = self._detected_callback
self.detector.start(detected_callback=callbacks,
audio_recorder_callback=self._conversation.converse,
interrupt_check=self._interrupt_callback,
silent_count_threshold=config.get('silent_threshold', 15),
recording_timeout=config.get('recording_timeout', 5) * 4,
sleep_time=0.03)
self.detector.terminate()
except Exception as e:
logger.critical('离线唤醒机制初始化失败：{}'.format(e))
def async_listen(call):
nonlocal detector, detected_event
from snowboy import snowboydecoder
detector = snowboydecoder.HotwordDetector(
model, sensitivity=sensitivity, audio_gain=audio_gain)
def detect():
detector.start(lambda: detected_event.set())
# Run detector in a separate thread
thread = threading.Thread(target=detect, daemon=True)
hass.states.async_set(OBJECT_SNOWBOY, STATE_LISTENING)
thread.start()
yield from asyncio.get_event_loop().run_in_executor(None, detected_event.wait)
if not terminated:
detector.terminate()
detector = None
thread.join()
hass.states.async_set(OBJECT_SNOWBOY, STATE_IDLE)
# Fire detected event
hass.bus.async_fire(EVENT_HOTWORD_DETECTED, {
'name': name, # name of the component
'model': model # model used
})
async def async_listen(call):
from snowboy import snowboydecoder
nonlocal detector
if detector == None:
detector = snowboydecoder.HotwordDetector(
model,
sensitivity=sensitivity,
audio_gain=audio_gain,
apply_frontend=apply_frontend)
def detect():
def callback():
# Fire detected event
_LOGGER.debug('hotword detected')
hass.bus.async_fire(
EVENT_HOTWORD_DETECTED,
{
'name': name, # name of the component
'model': model # model used
})
detector.terminate()
detector.start(callback)
# Run detector in a separate thread
hass.states.async_set(OBJECT_SNOWBOY, STATE_LISTENING, state_attrs)
with concurrent.futures.ThreadPoolExecutor() as pool:
await asyncio.get_event_loop().run_in_executor(pool, detect)
hass.states.async_set(OBJECT_SNOWBOY, STATE_IDLE, state_attrs)
def start_recognize_loop(self):
print('Initializing...')
# Configure Hotword detection.
model = self.config['hotword_detector']['model']
sensitivity = self.config['hotword_detector']['sensitivity']
self.detector = snowboydecoder.HotwordDetector(model, sensitivity=sensitivity)
# Configure voice recorder
self.config['recorder']['audio'] = self.get_stream_config()
self.voice_record = VoiceRecord(self.config['recorder'])
if 'bg_noise_samples' in self.config['recorder']:
self.voice_record.threshold = self.voice_record.measure_background_noise(num_samples=self.config['recorder']['bg_noise_samples'])
# Store audio config for services.
self.config['audio'] = self.config['recorder']['audio']
self.config['audio']['encoding'] = self.voice_record.ENCODING
self.create_services()
# main loop
print('Listening...')
self.set_interrupted(False)
self.detector.start(
detected_callback=lambda: self.command_handler(),
interrupt_check=self.interrupt_callback,
sleep_time=0.001)
print('Stop listening')
self.detector.terminate()
def run(self):
self.init()
models = [
constants.getHotwordModel(config.get('hotword', 'wukong.pmdl')),
constants.getHotwordModel(utils.get_do_not_bother_on_hotword()),
constants.getHotwordModel(utils.get_do_not_bother_off_hotword())
]
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, self._signal_handler)
detector = snowboydecoder.HotwordDetector(models,
sensitivity=config.get(
'sensitivity', 0.5))
print('Listening... Press Ctrl+C to exit')
# site
server.run()
# main loop
detector.start(detected_callback=[
self._detected_callback, self._do_not_bother_on_callback,
self._do_not_bother_off_callback
],
audio_recorder_callback=self._conversation.converse,
interrupt_check=self._interrupt_callback,
silent_count_threshold=5,
sleep_time=0.03)
detector.terminate()
def __init__(self):
QtWidgets.QMainWindow.__init__(self)
self.notice_trd = NoticeTrd(self)
self.notice_trd.changed_notice.connect(self.on_or_off_mark)
self.setupUi(self)
self.move(-2, 0)
self.verticalLayoutWidget.setGeometry(QtCore.QRect(400, 0, 400, 450))
self.pushButton_notice.clicked.connect(self.onClickNotice)
self.pushButton_food.clicked.connect(self.onClickFood)
self.pushButton_weather.clicked.connect(self.onClickWeather)
self.pushButton_shuttle.clicked.connect(self.onClickShuttle)
self.notice_trd.start()
self.on_or_off_mark()
self.lat = 37.340348
self.lon = 126.6984882
self.detector = snowboydecoder.HotwordDetector(
'snowboy/resources/이놈아.pmdl', sensitivity=0.6)
self.rc = recorder.Recorder()
self.tts = TTS()
self.stt = STT()
self.speaker = 'mijin'
speech_thread = threading.Thread(target=self.speechRecogStart)
speech_thread.daemon = True
speech_thread.start()
gps_thread = threading.Thread(target=self.gpsStart)
gps_thread.daemon = True
gps_thread.start()
def __init__(self):
self.interrupted = False
self.model = "snowboy.pmdl"
signal.signal(signal.SIGINT, self.signal_handler)
self.detector = snowboydecoder.HotwordDetector(self.model,
sensitivity=0.42)
print('Listening... Press Ctrl+C to exit')
self.robot = Robot()
self.music_player = self.robot.get_music_player()
self.player = Player()
def detect():
detector = snowboydecoder.HotwordDetector(model,
sensitivity=sensitivity,
audio_gain=audio_gain)
detector.start(lambda: detected_event.set(),
interrupt_check=interrupt_callback,
sleep_time=0.03)
detector.terminate()
def activate(self, context):
self.stop = False
detector = snowboydecoder.HotwordDetector(self.model, sensitivity=self.sensitivity)
print('Say "Hey Office" to wake me up...')
detector.start(detected_callback=self.__on_keyword_detected,
interrupt_check=self.__get_interrupt_check(context.is_interrupted),
sleep_time=self.sleep_time)
detector.terminate()
return TransitionContext('Listening', {})
def __init__(self):
self.interrupted = False
self.model = "嘿小二.pmdl" # 使用的语音模型
signal.signal(signal.SIGINT, self.signal_handler) # 捕获ctrl+c
self.detector = snowboydecoder.HotwordDetector(
self.model, sensitivity=0.5) # 设置语音模型与敏感度
print('Listening... Press Ctrl+Z to exit')
self.robot = Robot() # 创建应用模块
self.music_player = self.robot.get_music_player() # 创建音乐播放模块
self.player = Player() # 触发响应词叮咚播放
def detected_callback(cls):
cls.write_pid_file()
cls.run += 1
if cls.run >= 2:
print "Alexa > Oui maitre ?"
os.system("python run.py")
detector = snowboydecoder.HotwordDetector(
"models/Alexa.pmdl", sensitivity=0.48, audio_gain=1)
detector.start(cls.detected_callback)
def startKeyword():
# Configure keyword listener
models = ["resources/jarvis.pmdl"]
sensitivity = [0.45] * len(models)
detector = snowboydecoder.HotwordDetector(models, sensitivity=sensitivity)
callbacks = [lambda: activation_detected(detector)]
# Start keyword listener
print "Waiting for the keyword !"
detector.start(detected_callback=callbacks,
interrupt_check=interrupt_callback,
sleep_time=0.03)
def detect(self, detect_callback, interrupt_callback):
model = "resources/Hi_Sally.pmdl"
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.5)
print "Listening..."
detector.start(detected_callback=detect_callback,
interrupt_check=interrupt_callback,
sleep_time=0.03)
detector.terminate()
def detected_callback():
launch += 1
if launch >= 2:
print "Jarvis > Oui maitre ?"
system("python py_main.py")
detector = snowboydecoder.HotwordDetector("jarviss.pmdl",
sensitivity=0.37,
audio_gain=1)
detector.start(detected_callback)
def main():
signal.signal(signal.SIGINT, exit_handler)
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.38)
print('Listening... Press Ctrl+C to exit')
detector.start(detected_callback=detectedCallback,
audio_recorder_callback=audioRecorderCallback,
interrupt_check=interrupt_callback,
sleep_time=0.01)
detector.terminate()
def listen_for_hotword(model):
detector = snowboydecoder.HotwordDetector(model,
sensitivity=0.5,
audio_gain=1)
print('Listening... Press Ctrl+C to exit')
# main loop
detector.start(detected_callback=detected_callback,
audio_recorder_callback=audio_recorder_callback,
interrupt_check=interrupt_callback,
sleep_time=0.03,
silent_count_threshold=3,
save_path=CMD_AUDIO_SAVE_PATH)
detector.terminate()
def start(self):
# Register Ctrl-C sigint
signal.signal(signal.SIGINT, self._signal_handler)
# Setup snowboy
self.detector = snowboydecoder.HotwordDetector(self.model_path,
sensitivity=[0.5])
self.df_client = dfclient.MyDialogflowClient()
rospy.loginfo("HOTWORD_CLIENT: Listening... Press Ctrl-C to stop.")
while True:
try:
self.detector.start(detected_callback=self._snowboy_callback,
interrupt_check=self._interrupt_callback,
sleep_time=0.03)
except KeyboardInterrupt:
self.exit()
def hey_krystal():
"""
Detects "Hey Krystal"
:return:
"""
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
detector = snowboydecoder.HotwordDetector(AUDIO_MODEL, sensitivity=0.5)
# main loop
detector.start(detected_callback=snowboydecoder.play_audio_file,
interrupt_check=interrupt_callback,
sleep_time=0.03)
detector.terminate()
def __init__(self, model=None):
self.wav = xv_wav()
""" self.audio_frames 语音帧
大概1s/12帧，安每秒的list存入dict内 {"":["","","","","","","","","","","","",""],"":["","","","","","","","","","","","",""]......} """
self.audio_frames = {}
""" self.audio_seconds 需要识别语音片段，每秒一个dict元素 {"":"", "":""} """
self.audio_seconds = {}
if model is None:
self.model = 'snowboy'
if self.model == 'snowboy':
# 识别模型 snowboy
logging.info('loaded snowboy')
sensitivity = 0.5
model_file = '/home/app/xiaov/snowboy/xiaov.pmdl'
self.kws = snowboydecoder.HotwordDetector(model_file,
sensitivity=sensitivity)
def initDetector(self):
if self.detector is not None:
self.detector.terminate()
models = config.get('hotword', 'wukong.pmdl').split(',')
for i in range(0, len(models)):
models[i] = constants.getHotwordModel(models[i])
if config.get('/do_not_bother/hotword_switch', False):
models.append(
constants.getHotwordModel(
utils.get_do_not_bother_on_hotword()))
models.append(
constants.getHotwordModel(
utils.get_do_not_bother_off_hotword()))
logger.debug('init models:' + str(len(models)))
logger.debug(models)
self.detector = snowboydecoder.HotwordDetector(models,
sensitivity=config.get(
'sensitivity', 0.5))
logger.debug(self.detector)
# main loop
try:
callbacks = []
for i in range(
0, len(config.get('hotword', 'wukong.pmdl').split(','))):
callbacks.append(self._detected_callback)
if config.get('/do_not_bother/hotword_switch', False):
callbacks = [
self._detected_callback, self._do_not_bother_on_callback,
self._do_not_bother_off_callback
]
#else:
# callbacks = self._detected_callback
logger.debug('wukong callbacks:')
logger.debug(callbacks)
self.detector.start(
detected_callback=callbacks,
audio_recorder_callback=self._conversation.converse,
interrupt_check=self._interrupt_callback,
silent_count_threshold=config.get('silent_threshold', 15),
recording_timeout=config.get('recording_timeout', 5) * 4,
sleep_time=0.03)
self.detector.terminate()
except Exception as e:
logger.critical('离线唤醒机制初始化失败：{}'.format(e))
def __init__(self, voice_model_file, hotword=None, sensitivity=0.5,
audio_gain=1.0, **kwargs):
""" Params:
voice_model_file -- Snowboy voice model file
hotword -- Name of the hotword
"""
super().__init__(**kwargs)
self.voice_model_file = voice_model_file
self.hotword = hotword
self.sensitivity = sensitivity
self.audio_gain = audio_gain
self.detector = snowboydecoder.HotwordDetector(
self.voice_model_file, sensitivity=self.sensitivity,
audio_gain=self.audio_gain)
logging.info('Initialized Snowboy hotword detection')
def main():
print('Welcome to Voice Assistant!')
print(' Menu ')
print('1. Setup')
print('2. Access Assistant')
print('Please enter your option:')
opt = int(input())
if opt == 1:
print(' Setup Menu ')
print('1. Set Username')
print('2. Set Assistant Name')
print('3. Set Hotword')
print('Please enter your option:')
num = int(input())
if num == 1:
voice_assistant.speak('Welcome')
voice_assistant_setup.setup_username()
elif num == 2:
voice_assistant.speak('Welcome')
voice_assistant_setup.setup_assistant_name()
elif num == 3:
voice_assistant.speak('Welcome')
voice_assistant_setup.setup_hotword()
main()
elif opt == 2:
if not voice_assistant.username or voice_assistant.assistant_name:
voice_assistant.speak('Please set up voice assistant first')
else:
signal.signal(signal.SIGINT, signal_handler)
detector = snowboydecoder.HotwordDetector(model_loc,
sensitivity=0.5)
print('Listening... Press Ctrl+C to exit')
detector.start(detected_callback=attend_user(),
interrupt_check=interrupt_callback,
sleep_time=0.03)
detector.terminate()
def main():
init()
logger.debug('config: {}'.format(config.getConfig()))
models = [
constants.getHotwordModel(config.get('hotword', 'wukong.pmdl')),
constants.getHotwordModel(utils.get_do_not_bother_hotword())
]
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
detector = snowboydecoder.HotwordDetector(models,
sensitivity=config.get(
'sensitivity', 0.5))
print('Listening... Press Ctrl+C to exit')
# main loop
detector.start(
detected_callback=[detected_callback, do_not_bother_callback],
audio_recorder_callback=conversation,
interrupt_check=interrupt_callback,
silent_count_threshold=5,
sleep_time=0.03)
detector.terminate()
def __init__(self, strikes, cb_queue):
"""
Args:
strikes (deque): current attention status.
cb_queue (queue): callback queue for passing tasks between threads.
"""
# Logging.
logging.basicConfig()
self.logger = logging.getLogger("hotword")
self.logger.setLevel(logging.DEBUG)
self.end_detector = False
self.strikes = strikes
self.cb_queue = cb_queue
self.patronum_map = Hotword.load_map()
self.videos, self.models = self.load_videos_models()
self.update_map()
# Create detector.
sensitivities = [0.5] * len(self.models)
self.detector = sd.HotwordDetector(list(self.models),
resource="snowboy/common.res",
sensitivity=sensitivities,
audio_gain=1)
# Create detect thread.
callbacks = [self.gen_callbacks(self.patronum_map[m])
for m in list(self.models)]
hotword_kwargs = {"detected_callback": callbacks,
"interrupt_check": lambda: self.end_detector,
"sleep_time": 0.03}
self.detect_thread = threading.Thread(target=self.detector.start,
kwargs=hotword_kwargs)
self.detect_thread.start()
def signal_handler(signal, frame):
global interrupted
interrupted = True
def interrupt_callback():
global interrupted
return interrupted
model = sys.argv[1]
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.7)
assistant = Assistant()
def snowboy_detect_controller():
def detect_callback():
detector.terminate()
snowboydecoder.play_audio_file(snowboydecoder.DETECT_DING)
globalmodule.assistantcontroller = True
globalmodule.hotworddetected = False
while True:
if globalmodule.snowboycontroller:
globalmodule.snowboycontroller = False
logger.info('Listening... Press Ctrl+C to exit')
detector.start(detected_callback=detect_callback,
interrupt_check=interrupt_callback,
def start_recording():
detector = snowboydecoder.HotwordDetector('hotword.pmdl', sensitivity=0.5)
detector.start(is_recording=True)
detector.terminate()
def wait_for_hotword():
detector = snowboydecoder.HotwordDetector('hotword.pmdl', sensitivity=0.5)
print('Listening... Press Ctrl+C to exit')
detector.start()
detector.terminate()