def main(): logging.basicConfig(level=logging.DEBUG) src = Source(rate=16000) kws = KWS(model='alexa') alexa = Alexa() alexa.state_listener.on_listening = pixels.listen alexa.state_listener.on_thinking = pixels.think alexa.state_listener.on_speaking = pixels.speak alexa.state_listener.on_finished = pixels.off def on_detected(keyword): logging.info('detected {}'.format(keyword)) alexa.listen() kws.on_detected = on_detected src.link(kws) kws.link(alexa) src.recursive_start() while True: try: time.sleep(1) except KeyboardInterrupt: break src.recursive_stop()
def main(): logging.basicConfig(level=logging.DEBUG) src = Source(rate=16000) ns = NS(rate=16000, channels=1) kws = KWS() alexa = Alexa(model='alexa') src.link(ns) ns.link(kws) kws.link(alexa) def on_detected(keyword): logging.info('detected {}'.format(keyword)) alexa.listen() kws.set_callback(on_detected) src.recursive_start() while True: try: time.sleep(1) except KeyboardInterrupt: break src.recursive_stop()
def main(): logging.basicConfig(level=logging.DEBUG) src = Source(rate=16000, channels=8) ch1 = ChannelPicker(channels=8, pick=1) ns = NS(rate=16000, channels=1) kws = KWS(model='alexa') doa = DOA(rate=16000) alexa = Alexa() src.link(ch1) ch1.link(ns) ns.link(kws) kws.link(alexa) src.link(doa) def on_detected(keyword): logging.info('detected {} at direction {}'.format( keyword, doa.get_direction())) alexa.listen() kws.set_callback(on_detected) src.recursive_start() while True: try: time.sleep(1) except KeyboardInterrupt: break src.recursive_stop()
class StateMachine: def __init__(self, wake_word_model): self.__src = Source(rate=16000) self.__ns = NS(rate=16000, channels=1) self.__kws = KWS(model=wake_word_model) self.__alexa = Alexa() self.__src.link(self.__ns) self.__ns.link(self.__kws) self.__kws.link(self.__alexa) self.__pixels = ThreePixels() self.__button = Button() self.__alexa.state_listener.on_listening = self.on_listening self.__alexa.state_listener.on_thinking = self.on_thinking self.__alexa.state_listener.on_speaking = self.on_speaking self.__alexa.state_listener.on_finished = self.on_finished def on_listening(self): self.__pixels.wakeup() def on_thinking(self): self.__pixels.think() def on_speaking(self): self.__pixels.speak() def on_finished(self): self.__pixels.off() def __on_detected(self, keyword): print('detected {}'.format(keyword)) print('Alexa is listening!') self.__alexa.listen() def __pushed_button(self, channel): print('button pushed') print('Alexa is listening!') self.__alexa.listen() def start(self): print('starting voice engine') self.__kws.set_callback(self.__on_detected) Button.set_callback_on_rising(self.__pushed_button) self.__src.recursive_start() def stop(self): print('stopping voice engine') self.__src.recursive_stop() Button.clean_up() self.__pixels.off()
def main(): logging.basicConfig(level=logging.DEBUG) src = Source(rate=16000, channels=4) ch1 = ChannelPicker(channels=4, pick=1) ns = NS(rate=16000, channels=1) kws = KWS(model='snowboy') doa = DOA(rate=16000) alexa = Alexa() alexa.state_listener.on_listening = pixels.listen alexa.state_listener.on_thinking = pixels.think alexa.state_listener.on_speaking = pixels.speak alexa.state_listener.on_finished = pixels.off def on_detected(keyword): direction = doa.get_direction() logging.info('detected {} at direction {}'.format(keyword, direction)) pixels.wakeup(direction) alexa.listen() kws.on_detected = on_detected src.link(ch1) ch1.link(ns) ns.link(kws) kws.link(alexa) src.link(doa) src.recursive_start() while True: try: time.sleep(1) except KeyboardInterrupt: break src.recursive_stop()
def main(): src = Source(rate=16000, frames_size=320, channels=8) # ds = DelaySum(channels=8, frames_size=src.frames_size, max_offset=max_offset) ch0 = ChannelPicker(channels=src.channels, pick=0) kws = KWS() # doa = DOA(rate=16000, chunks=20) alexa = Alexa() # alexa.state_listener.on_listening = pixel_ring.listen # alexa.state_listener.on_thinking = pixel_ring.think # alexa.state_listener.on_speaking = pixel_ring.speak # alexa.state_listener.on_finished = pixel_ring.off src.link(ch0) ch0.link(kws) kws.link(alexa) # src.link(doa) def on_detected(keyword): # direction = doa.get_direction() alexa.listen() # pixel_ring.wakeup((direction + 0) % 360) # print('detected {} at direction {}'.format(keyword, direction)) print('detected keyword') kws.on_detected = on_detected src.recursive_start() while True: try: time.sleep(1) except KeyboardInterrupt: print('quit') break src.recursive_stop()
def main(): logging.basicConfig(level=logging.DEBUG) src = Source(rate=16000, channels=4, device_name='default') ds = DelaySum(channels=src.channels) ns = NS(rate=16000, channels=1) kws = KWS(model='alexa') alexa = Alexa() alexa.state_listener.on_listening = leds_on # alexa.state_listener.on_thinking = pixel_ring.think # alexa.state_listener.on_speaking = pixel_ring.speak alexa.state_listener.on_finished = leds_off src.link(ds) ds.link(ns) ns.link(kws) kws.link(alexa) def on_detected(keyword): logging.info('\ndetected {}'.format(keyword)) alexa.listen() kws.set_callback(on_detected) is_quit = [] def signal_handler(sig, frame): is_quit.append(True) print('quit') signal.signal(signal.SIGINT, signal_handler) src.pipeline_start() while not is_quit: time.sleep(1) src.pipeline_stop()
import time import signal from voice_engine.source import Source from voice_engine.kws import KWS from voice_engine.ns import NS from avs.alexa import Alexa src = Source(rate=16000) ns = NS(rate=16000, channels=1) kws = KWS(model='/home/pi/coach/alexa.pmdl') alexa = Alexa() src.link(ns) ns.link(kws) kws.link(alexa) def on_detected(keyword): print('detected {}'.format(keyword)) print('Alexa is listening!') alexa.listen() kws.set_callback(on_detected) is_quit = [] def signal_handler(signal, frame): print('Quit') is_quit.append(True)
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, verbose, grpc_deadline, once, *args, **kwargs): """Samples for the Google Assistant API. Examples: Run the sample with microphone input and speaker output: $ python -m googlesamples.assistant Run the sample with file input and speaker output: $ python -m googlesamples.assistant -i <input file> Run the sample with file input and output: $ python -m googlesamples.assistant -i <input file> -o <output file> """ # Setup logging. logging.basicConfig(level=logging.DEBUG if verbose else logging.INFO) # Load OAuth 2.0 credentials. try: with open(credentials, 'r') as f: credentials = google.oauth2.credentials.Credentials(token=None, **json.load(f)) http_request = google.auth.transport.requests.Request() credentials.refresh(http_request) except Exception as e: logging.error('Error loading credentials: %s', e) logging.error('Run google-oauthlib-tool to initialize ' 'new OAuth 2.0 credentials.') sys.exit(-1) # Create an authorized gRPC channel. grpc_channel = google.auth.transport.grpc.secure_authorized_channel( credentials, http_request, api_endpoint) logging.info('Connecting to %s', api_endpoint) if not device_id or not device_model_id: try: with open(device_config) as f: device = json.load(f) device_id = device['id'] device_model_id = device['model_id'] logging.info("Using device model %s and device id %s", device_model_id, device_id) except Exception as e: logging.warning('Device config not found: %s' % e) logging.info('Registering device') if not device_model_id: logging.error('Option --device-model-id required ' 'when registering a device instance.') sys.exit(-1) if not project_id: logging.error('Option --project-id required ' 'when registering a device instance.') sys.exit(-1) device_base_url = ('https://%s/v1alpha2/projects/%s/devices' % (api_endpoint, project_id)) device_id = str(uuid.uuid1()) payload = { 'id': device_id, 'model_id': device_model_id, 'client_type': 'SDK_SERVICE' } session = google.auth.transport.requests.AuthorizedSession( credentials) r = session.post(device_base_url, data=json.dumps(payload)) if r.status_code != 200: logging.error('Failed to register device: %s', r.text) sys.exit(-1) logging.info('Device registered: %s', device_id) pathlib.Path(os.path.dirname(device_config)).mkdir(exist_ok=True) with open(device_config, 'w') as f: json.dump(payload, f) assistant = SampleAssistant(lang, device_model_id, device_id, grpc_channel, grpc_deadline) src = Source(rate=16000, frames_size=1600) kws = KWS(model='snowboy', sensitivity=0.6) src.link(kws) kws.link(assistant) def on_keyword(keyword): print('detected') assistant.listen() quit_event = threading.Event() def on_interrupt(sig, frame): print('quit') quit_event.set() signal.signal(signal.SIGINT, on_interrupt) kws.on_detected = on_keyword assistant.start() kws.start() src.start() while not quit_event.is_set(): time.sleep(1) src.stop() kws.stop() assistant.stop()