def main():
global interrupted
global is_quit
snowboydecoder.play_audio_file(snowboydecoder.DETECT_DING)
while True:
models = ["resources/heyrobo.pmdl", "resources/abort.pmdl"]
sensitivity = [0.5] * len(models)
detector = snowboydecoder.HotwordDetector(models,
sensitivity=sensitivity)
callbacks = [lambda: quit_detect(), lambda: quit_detect()]
detector.start(detected_callback=callbacks,
interrupt_check=interrupt_callback,
sleep_time=0.03)
#quit if aborted here
if is_quit:
snowboydecoder.play_audio_file(snowboydecoder.DETECT_DONG)
break
else:
interrupted = False
models = [
"resources/forward.pmdl", "resources/backward.pmdl",
"resources/left.pmdl", "resources/right.pmdl",
"resources/stop.pmdl", "resources/abort.pmdl"
]
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
sensitivity = [0.5] * len(models)
detector = snowboydecoder.HotwordDetector(models,
sensitivity=sensitivity)
callbacks = [
lambda: executeCmd("Forward"), lambda: executeCmd("Backward"),
lambda: executeCmd("Left"), lambda: executeCmd("Right"),
lambda: executeCmd("Stop"), lambda: executeCmd("Abort")
]
snowboydecoder.play_audio_file(snowboydecoder.DETECT_DING)
print('Listening... Press Ctrl+C to exit')
# main loop
# make sure you have the same numbers of callbacks and models
detector.start(detected_callback=callbacks,
interrupt_check=interrupt_callback,
sleep_time=0.03)
print("Heyrobo aborted")
interrupted = False
detector.terminate()
def initialize_detectors(self):
"""
Returns initialized Catpie HotwordDetector objects
"""
self.detectors = snowboydecoder.HotwordDetector(
self.models, self.actions, **self.init_kwargs)
while not self.detectors.hasAudio:
self.detectors.terminate()
time.sleep(5)
self.detectors = snowboydecoder.HotwordDetector(
self.models, self.actions, **self.init_kwargs)
def main():
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.6)
recognizer = aiy.cloudspeech.get_recognizer()
status_ui = aiy.voicehat.get_status_ui()
aiy.audio.get_recorder().start()
while True:
print('INFO:Speak Wake Word and speak')
status_ui.status('ready')
global interrupted
interrupted = False
detector.start(detected_callback=callbacks,
interrupt_check=interrupt_callback,
sleep_time=0.03)
print('INFO:Listening...')
status_ui.status('thinking')
text = recognizer.recognize()
if not text:
print('INFO:Sorry, I did not hear you.')
elif text in skills:
print('INFO:Skill:', text, '"')
skills[text]()
else:
print('INFO:"', text, '"')
call_assistant(text)
def __init__(self, model, assistant, sensitivity=0.5, audio_gain=1.0):
"""
:param model: Path to the voice model file. See https://snowboy.kitt.ai/ for training/downloading models.
:type model: str
:param assistant: Instance of :class:`assistant.Assistant` that will be invoked upon detected hotword.
:type assistant: assistant.Assistant
:param sensitivity: Model sensitivity for hotword detection between 0 and 1 (default: 0.5)
:type sensitivity: float
:param audio_gain: Audio gain. Default: 1.0
:type audio_gain: float
"""
super().__init__()
self.model_file = os.path.abspath(os.path.expanduser(model))
self.assistant = assistant
self.sensitivity = sensitivity
self.audio_gain = audio_gain
self.logger = logging.getLogger(__name__)
self.logger.addHandler(logging.StreamHandler(sys.stdout))
self.detector = snowboydecoder.HotwordDetector(self.model_file,
sensitivity=self.sensitivity,
audio_gain=self.audio_gain)
self.logger.info('Initialized hotword detection service')
def main():
recognizer = sr.Recognizer()
rgb = Squid(RED_GPIO_LEAD, GREEN_GPIO_LEAD, BLUE_GPIO_LEAD)
snowboy_detector = snowboydecoder.HotwordDetector(
SNOWBOY_HOTWORD_LOCATION,
sensitivity=0.5,
audio_gain=1
)
while True:
snowboy_detector.listen()
rgb.set_color(GREEN)
with sr.Microphone(device_index=2) as source:
audio = recognizer.listen(source=source, timeout=5, phrase_time_limit=2)
rgb.set_color(BLUE)
processor = Processor(audio=audio)
try:
processor.run()
except:
rgb.set_color(RED)
sleep(1)
rgb.set_color(OFF)
def start_detection(self, callback_func):
signal.signal(signal.SIGINT, self.signal_handler)
self.detector = snowboydecoder.HotwordDetector(self.model,
sensitivity=0.5)
self.detector.start(detected_callback=callback_func,
interrupt_check=self.interrupt_callback,
sleep_time=0.5)
def main():
global detector
global stt
global config
global tuling
global rap
if len(sys.argv) == 1:
print("Error: need to specify model name")
print("Usage: python demo.py your.model")
sys.exit(-1)
with open("./config.yaml") as f:
config = yaml.load(f)
stt = Baidu(config)
tuling = Tuling(config)
rap = rapiro('http://192.168.123.87')
print(len(sys.argv))
model = sys.argv[1]
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.5)
print('Listening... Press Ctrl+C to exit')
# main loop
detector.start(detected_callback=detected_callback,
interrupt_check=interrupt_callback,
sleep_time=0.03)
detector.terminate()
def start(self):
interrupted = False
def signal_handler(signal, frame):
global interrupted
interrupted = True
def interrupt_callback():
global interrupted
return interrupted
if len(sys.argv) == 1:
print("Error: need to specify model name")
print("Usage: python demo.py your.model")
sys.exit(-1)
model = self.model
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.5)
print('Listening... Press Ctrl+C to exit')
# main loop
detector.start(detected_callback=snowboydecoder.play_audio_file,
interrupt_check=interrupt_callback,
sleep_time=0.03)
detector.terminate()
return interrupted
def listening():
detector = snowboydecoder.HotwordDetector(hotword_model,
sensitivity=0.38)
print("Listening... <hotword>, Press Ctrl+C to exit")
detector.start(detected_callback=detectedCallback, sleep_time=0.01)
detector.terminate()
def hotword_detector():
print("Tell the keyword to start conversation")
detector = snowboydecoder.HotwordDetector("resources/saya.pmdl", sensitivity=0.4, audio_gain=1)
detector.start(detected_callback)
def main():
model = sys.argv[1] # path to hot-word model
model = 'resources/alexa.umdl'
mixer.init(frequency=16000)
# Baidu Voice API, you may need to update your tokens.
token = BaiduVoice.get_baidu_token('VB5dnaiN1uM3b2tWbUYcOFzE',
'9577cd3eaa69b68040fdfd204fcd19c1')
bv = BaiduVoice(token['access_token'])
# Turing Robots Tokens
chatbot = TuringRobot('2b3e14182a7b4cdaa34d1bb65020f822')
# ROS topic
rospy.init_node('chatbot-node')
pub = rospy.Publisher('/cmd_vel_mux/input/teleop', Twist, queue_size=1)
# Hot word detector
signal.signal(signal.SIGINT, signal_handler)
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.9)
print('Listening... Press Ctrl+C to exit')
# main loop
detector.start(
detected_callback=lambda: chatbot_callback(bv, chatbot, pub),
interrupt_check=interrupt_callback,
sleep_time=0.03)
detector.terminate()
def start(self):
"""Begin listening to spoken commands.
Note: Control will stay within this object.
"""
# Grab my callback methods, find the appropriate models, and set up the
# sensitivities for each
callbacks = []
models = []
sensitivities = []
command_mapping = Body.get_commands()
for command, sensitivity in command_mapping.items():
callbacks.append(lambda: command(self))
models.append('models/{}.pmdl'.format(command.__name__))
sensitivities.append(sensitivity)
# If I see an interrupt, then I need to stop running
signal.signal(signal.SIGINT, self.stop)
detectors = snowboydecoder.HotwordDetector(models,
sensitivity=sensitivities)
# Designate me as a running instance
self.is_running = True
detectors.start(
detected_callback=callbacks,
# If I should no longer be running, then interrupt me
interrupt_check=lambda: not self.is_running,
sleep_time=.03)
detectors.terminate()
def __init__(self):
self.interrupted=False
self.can_start_conversation=False
self.assistant=None
self.sensitivity = [0.5]*len(models)
self.callbacks = [self.detected]*len(models)
self.detector = snowboydecoder.HotwordDetector(models, sensitivity=self.sensitivity)
self.mutestatus=False
self.interpreter=False
self.interpconvcounter=0
self.interpcloudlang1=language
self.interpttslang1=translanguage
self.interpcloudlang2=''
self.interpttslang2=''
self.singleresposne=False
self.singledetectedresponse=''
self.t1 = Thread(target=self.start_detector)
if GPIOcontrol:
self.t2 = Thread(target=self.pushbutton)
if configuration['MQTT']['MQTT_Control']=='Enabled':
self.t3 = Thread(target=self.mqtt_start)
if irreceiver!=None:
self.t4 = Thread(target=self.ircommands)
if configuration['ADAFRUIT_IO']['ADAFRUIT_IO_CONTROL']=='Enabled':
self.t5 = Thread(target=self.adafruit_mqtt_start)
def awaken():
detector = snowboydecoder.HotwordDetector(
"/home/pi/xiaolan/xiaolan/snowboy/Alexa.pmdl",
sensitivity=0.5,
audio_gain=1)
detector.start(detected_callback)
def start_hotword_detection(self):
self.detector = snowboydecoder.HotwordDetector(
["resources/Alice.pmdl", "resources/stop_the_music.pmdl"],
sensitivity=[0.45, 0.50],
audio_gain=3
)
self.detector.start([self.detected_callback, self.stop_music_callback])
def startNLP(model):
#model = sys.argv[1]
def detectedCallback():
detector.terminate() # So google Assistant can use audio device
snowboydecoder.play_audio_file(snowboydecoder.DETECT_DING)
assistant.startAssist()
snowboydecoder.play_audio_file(snowboydecoder.DETECT_DONG)
detector.start(detected_callback=detectedCallback,
interrupt_check=interrupt_callback,
sleep_time=0.03)
i2c = I2C(SLAVE_ADDR)
assistant = GoogleAssistant(i2c)
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
# The obj contains the hotword detection
snowboydecoder.play_audio_file(snowboydecoder.DETECT_DING)
snowboydecoder.play_audio_file(snowboydecoder.DETECT_DONG)
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.5)
print('Listening... Press Ctrl+C to exit')
# main loop
detector.start(
detected_callback=detectedCallback, #snowboydecoder.play_audio_file,
interrupt_check=interrupt_callback,
sleep_time=0.03)
detector.terminate()
def wake_up():
global detector
model = 'snowboy.pmdl' # 唤醒词为 SnowBoy
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
# 唤醒词检测函数，调整sensitivity参数可修改唤醒词检测的准确性
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.5)
print('Listening... please say wake-up word:SnowBoy')
# main loop
# 回调函数
detected_callback = snowboydecoder.play_audio_file
# 修改回调函数可实现我们想要的功能
detector.start(
detected_callback=callbacks, # 自定义回调函数
interrupt_check=interrupt_callback,
sleep_time=0.03)
# 释放资源
detector.terminate()
def start_word_detected():
print("got the start keyword !")
# first terminate the start detector
startDetector.terminate()
# then start recognizing
print("now time to start the talk ! ")
# obtain audio from the microphone
r = sr.Recognizer()
m = sr.Microphone()
while True:
res = interact_with_device(r, m)
# if no exception was launched
if res["error"] is None:
print(u"You said: {}".format(res["transcription"]))
processed = process_result(res["transcription"])
if processed is True or stop_word_detected is True:
break
# if we come here : means that interaction is over
global stop_word_detected
stop_word_detected = False
print "back to detecting hotword"
# start the thread of the detector
global startDetector
startDetector = snowboydecoder.HotwordDetector(startModel, sensitivity=0.5)
startDetector.start(detected_callback=start_word_detected,
interrupt_check=interrupt_callback,
sleep_time=0.03)
def snowboy():
hotword_file = Aion().get_hotword_file()
logger.info("Set the hotword file", getframeinfo(currentframe()).lineno - 1)
try:
global main_pid
main_pid = os.getpid()
print("Main PID: " + str(main_pid))
wake_up = snowboydecoder.HotwordDetector(hotword_file, sensitivity=0.5)
logger.info("Configured the hotword detector", getframeinfo(currentframe()).lineno - 1)
logger.info("Starting hotword detection...", getframeinfo(currentframe()).lineno - 1)
wake_up.start(detected_callback=detected_callback,
audio_recorder_callback=main,
recording_timeout=50,
sleep_time=0.01)
wake_up.terminate()
except KeyboardInterrupt:
variables.close()
sys.exit(1)
except Exception:
print(Fore.CYAN + "Caught error: " + Fore.RED + "\n" + traceback.format_exc() + Fore.RESET)
error_list = []
for error in traceback.format_exc().split("\n"):
error_list.append(error.strip())
logger.error("Caught error: " + " |-| ".join(error_list), getframeinfo(currentframe()).lineno - 5)
pass
def main():
global ws
global gloop
global detector
global interrupted
global listening
interrupted=False
listening=False
model = "resources/alexa/alexa_02092017.umdl"
ws = WebsocketClient('ws://localhost:8181/core')
ws.on('open', handle_open)
ws.on('recognizer_loop:wakeword', handle_startlisten)
ws.on('StartListen', handle_startlisten)
gloop=google_recognizer()
gloop.on('UtteranceDetected',detected_utterance)
event_thread = Thread(target=mycroft_connect)
event_thread.setDaemon(True)
event_thread.start()
signal.signal(signal.SIGINT, signal_handler)
detector = snowboydecoder.HotwordDetector(model, sensitivity=0.2)
time.sleep(1)
print('Listening...')
detector.start(detected_callback=callback_wakeword,
interrupt_check=interrupt_callback,
sleep_time=0.05)
detector.terminate()
def detectWake():
def signal_handler(signal, frame):
global interrupted
interrupted = True
def interrupt_callback():
global interrupted
return interrupted
def callback():
snowboydecoder.play_audio_file(snowboydecoder.DETECT_DING)
detector.terminate()
getUtterance()
models = setti.models
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
sensitivity = [0.5] * len(models)
detector = snowboydecoder.HotwordDetector(models, sensitivity=sensitivity)
callbacks = [callback] * len(models)
detector.start(detected_callback=callbacks,
interrupt_check=interrupt_callback,
sleep_time=0.03)
def detect_language(self, request = None):
"""
Detecting a hotword from a model, returning a language code
Keyword arguments:
request = ROS Service Message
"""
# Setting parameters
languages = ['en-EN', 'de-DE', 'es-ES', 'it-IT', 'nl-NL']
models = [model_path + "HeyDeNiro.pmdl",
model_path + "HalloDeNiro.pmdl",
model_path + "HolaDeNiro.pmdl",
model_path + "CiaoDeNiro.pmdl",
model_path + "HoiDeNiro.pmdl"]
sensitivity = [0.5]*len(models)
# Initializing Snowboy (Hotword Detector)
detector = snowboydecoder.HotwordDetector(models, sensitivity=sensitivity)
try:
lang = [None]
callbacks = [lambda i=i: _return_language(languages[i], lang) for i, val in enumerate(models)]
detector.start(detected_callback=callbacks, sleep_time=0.03, file=self.file)
except KeyboardInterrupt: # pragma: no cover
pass
detector.terminate()
print "Returning: " + str(lang[0])
return lang[0]
def detect_hotword(self, request = None):
"""
Detecting a hotword from a model
Keyword arguments:
request = ROS Service Message
"""
# Setting parameters
models = {
'en-EN' : model_path + "HeyDeNiro.pmdl",
'de-DE' : model_path + "HalloDeNiro.pmdl",
'es-ES' : model_path + "HolaDeNiro.pmdl",
'it-IT' : model_path + "CiaoDeNiro.pmdl",
'nl-NL' : model_path + "HoiDeNiro.pmdl"
}
sensitivity = [0.5]
# Initializing Snowboy (Hotword Detector)
detector = snowboydecoder.HotwordDetector(models[request.lang_in], sensitivity=sensitivity)
try:
detector.start(sleep_time=0.03, file=self.file)
except KeyboardInterrupt: # pragma: no cover
pass
detector.terminate()
print "Returning: " + str(request.lang_in)
return request.lang_in
def speechrec_main(listFName):
models = load_model_list(listFName)
print 'models = ', models
time.sleep(1)
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, signal_handler)
sensitivity = [0.5] * len(models)
detector = snowboydecoder.HotwordDetector(models, sensitivity=sensitivity)
callbacks = [
lambda: my_callback(0, models[0]), lambda: my_callback(1, models[1]),
lambda: my_callback(2, models[2]), lambda: my_callback(3, models[3]),
lambda: midi_play.Pausepress(), lambda: midi_play.Pausepress(),
lambda: midi_play.Pausepress(), lambda: midi_play.Pausepress(),
lambda: midi_play.Fastpress(), lambda: midi_play.Fastpress(),
lambda: midi_play.Slowpress(), lambda: midi_play.Slowpress(),
lambda: my_callback(12, models[12]),
lambda: my_callback(13, models[13]),
lambda: my_callback(14, models[14]),
lambda: my_callback(15, models[15]),
lambda: my_callback(16, models[16]),
lambda: my_callback(17, models[17]),
lambda: my_callback(18, models[18]),
lambda: my_callback(19, models[19])
]
print('Listening... Press Ctrl+C to exit')
# main loop
# make sure you have the same numbers of callbacks and models
detector.start(detected_callback=callbacks,
interrupt_check=interrupt_callback,
sleep_time=0.5)
detector.terminate()
def __init__(self, models):
# Flags
self._detected = False
self._stop = True
# capture SIGINT signal, e.g., Ctrl+C
signal.signal(signal.SIGINT, self.signal_handler)
# A timer object as well incase we need to detect within a timeout
self._timeout_timer = None
# init the detector
sensitivity = [0.465] * len(models) # 0.465 is really well-tuned to Angel
self.detector = \
snowboydecoder.HotwordDetector(models, sensitivity=sensitivity)
self.callbacks = [self.notify] * len(models)
# detection service
self._srv = rospy.Service('/detect_hotword',
DetectHotWordSrv,
self._srv_callback)
# hotword detection action
self._action = actionlib.SimpleActionServer('/detect_hotword',
DetectHotWordAction,
self._action_callback,
auto_start=False)
self._action.register_preempt_callback(self._action_preempt)
self._action.start()
# notify programmmer of init
rospy.loginfo(rospy.get_name() + ': hotword detector initialized!')
def startBurton():
global detector
detector.terminate()
burton.runOnce()
detector = snowboydecoder.HotwordDetector(models, sensitivity=sensitivity)
detector.start(detected_callback=callbacks,
interrupt_check=interrupt_callback,
sleep_time=0.03)
def awaken(self):
detector = snowboydecoder.HotwordDetector(
"/home/pi/xiaolan/auditory_center/awaken/hotword/jarvis.umdl,/home/pi/xiaolan/auditory_center/awaken/hotword/xiaodu_l12r10_sen_35_35_32_highsen_40_40_39_0104_kuanyang.umdl",
sensitivity=[0.8, 0.8, 0.4, 0.4, 0.39],
audio_gain=1,
apply_frontend=True)
detector.start(self.a)
def hotWord(models): sensitivity = [0.5]*len(models) detector = snowboydecoder.HotwordDetector(models, sensitivity=sensitivity) # main loop word = detector.start(detected_callback=snowboydecoder.play_audio_file, sleep_time=0.03) return(word)
def __init__(self):
self.interrupted=False
self.can_start_conversation=False
self.assistant=None
self.sensitivity = [0.5]*len(models)
self.callbacks = [self.detected]*len(models)
self.detector = snowboydecoder.HotwordDetector(models, sensitivity=self.sensitivity)
self.t1 = Thread(target=self.start_detector)
def start_listening(self):
detector = snowboydecoder.HotwordDetector(self.model, sensitivity=0.5)
print('Listening... Press Ctrl+C to exit')
detector.start(detected_callback=self.hotword_callback,
sleep_time=0.03)
detector.terminate()
