def __init__(self, device_index=None, sample_rate=16000, chunk_size=1024, mute=False): Microphone.__init__(self, device_index=device_index, sample_rate=sample_rate, chunk_size=chunk_size) self.muted = False if mute: self.mute()
def main(): # start to listen background with another thread. start_listen_background() while not os.path.exists(BG_WAV_PATH): print('ready for bg wav ...') time.sleep(1) # initialize recognizer recognizer = Recognizer() recognizer.speaking_duration = 0.1 recognizer.phrase_threshold = 0.1 with Microphone(sample_rate=SAMPLE_RATE) as source: # listen for 1 second to calibrate the energy threshold for ambient noise levels recognizer.adjust_for_ambient_noise(source) print("Calibrated. Say something!") source = Microphone(sample_rate=SAMPLE_RATE) with Pool(THREAD_NUM) as pool: callback_with_model = partial(callback, model_map=ModelMap(), pool=pool) recognizer.listen_in_background(source, callback_with_model, PHRASE_TIME_LIMIT) while True: time.sleep(10)
def __init__(self, device_index=None, sample_rate=16000, chunk_size=1024, mute=False): Microphone.__init__( self, device_index=device_index, sample_rate=sample_rate, chunk_size=chunk_size) self.muted = False if mute: self.mute()
class UserAudioSource(AudioSource): """Represent user audio input.""" def __init__(self) -> None: self._micro = Microphone() def __enter__(self) -> Microphone: return self._micro.__enter__() def __exit__(self, exc_type, exc_val, exc_tb) -> None: return self._micro.__exit__(exc_type, exc_val, exc_tb)
def gettingWordsFromMic(): mic = Microphone() recognizer = Recognizer() print("Say something...") print(Microphone.list_microphone_names()) with mic as source: recognizer.adjust_for_ambient_noise(source) audio = recognizer.listen(source) input("Press a key to process") print(recognizer.recognize_google(audio))
def audio_to_text(message_input): # initialise the recognizer r = Recognizer() # Use the sysdefault microphone for i, microphone_name in enumerate(Microphone.list_microphone_names()): if microphone_name == "sysdefault": micro = Microphone(device_index=i) with micro as source: # Extract the audio and convert it to text audio = r.listen(source) # recognize speech using Google Speech Recognition and add it to the text input area try: message_input.setText(r.recognize_google(audio)) except UnknownValueError: message_input.setText('The audio was not understood')
def __init__(self, pin: int = 17, language: str = "en", api: str = "", mic=None) -> None: """ Initialize LED lights, button, language, microphone, and recognizer. pin: tell Pi what pin to use for LED and set it's default value to 0 (off) language: set language to the language you are translating from microphone: initialize microphone so it can be used in this program recognizer: take input from microphone and decipher it into text Microphone.list_microphone_names() to list all microphones Pass the needed device as device_index=n if program can't pick up device automatically """ self.microphone = Microphone( device_index=mic) if mic else Listener.get_mic() self.recognizer = Recognizer() self.led = PWMLED(pin) self.src = language self.target = "es" self.api = api
def listen_continuously() -> Callable[[bool], None]: """ Listen for speech continuously, send each sentence to a speech-to-text converter, then send the text to the server. Sentences are detected by pauses in the speech. """ # look for the microphone specified in config file mics_lst = sr.Microphone.list_microphone_names() mic = None for i, m in enumerate(mics_lst): if m == config.mic_name: mic = Microphone(device_index=i) if mic is None: msg = "No microphone can be found!" log(msg, level=logging.ERROR, remote=False) raise Exception(msg) recognizer = sr.Recognizer() log("adjusting to noise for {0} sec".format(config.noise_adjustment_time), remote=False) with mic as source: recognizer.adjust_for_ambient_noise( duration=config.noise_adjustment_time, source=source) log("listening!", remote=True) # stop_listening is a function that when called stops the background listening stop_listening_func = recognizer.listen_in_background( mic, callback=listening_callback, phrase_time_limit=config.recognizer_phrase_time_limit) return stop_listening_func
def __init__(self, callback, language="pl-PL", api_option=ApiOption.GOOGLE): super().__init__() self.callback_command_detected = callback self.api_option = api_option self.language = language self.listen_thread = None self.phrase_time_limit = 3 try: self.recognizer = Recognizer() self.microphone = Microphone() """ adjust the recognizer sensitivity to ambient noise and record audio from the microphone """ with self.microphone as source: self.recognizer.adjust_for_ambient_noise(source) except OSError as ose_err: Logger.critical("OSError: {0}".format(ose_err)) self.api_runs = False self.api_info = GLO_MSG['MICROPHONE_FAILURE'] return except Exception as err: Logger.critical("Exception: {0}".format(err)) self.api_runs = False self.api_info = GLO_MSG['MICROPHONE_FAILURE'] return Logger.debug("Initialization of CommandsRecognition class") self.api_info = GLO_MSG['MICROPHONE_INITIALIZED']
def listen_background(): background_listener = noisered.BackgroundListener() with Microphone(sample_rate=SAMPLE_RATE) as source: background_listener.adjust_for_ambient_noise(source) while os.path.exists(SHARED_MEM_DIR): audio_data = background_listener.listen(source, pause_time_limit=5) if not audio_data: print("background listener: no audio data") time.sleep(1) continue segment = extract_silence(audio_data.get_wav_data()) if not segment: print("background listener: no silence") time.sleep(1) continue segment.export(BG_WAV_PATH + '.tmp', format='wav', bitrate=256) with noisered.SEMAPHORE: try: os.remove(BG_WAV_PATH) except: pass # create wav file os.rename(BG_WAV_PATH + '.tmp', BG_WAV_PATH) print(f"export bgm. {BG_WAV_PATH}. size={len(segment)}")
def listen(timeout: Union[int, float], phrase_limit: Union[int, float], sound: bool = True, stdout: bool = True) -> Union[str, None]: """Function to activate listener, this function will be called by most upcoming functions to listen to user input. Args: timeout: Time in seconds for the overall listener to be active. phrase_limit: Time in seconds for the listener to actively listen to a sound. sound: Flag whether to play the listener indicator sound. Defaults to True unless set to False. stdout: Flag whether to print the listener status on screen. Returns: str: - Returns recognized statement from the microphone. """ with Microphone() as source: try: playsound(sound=indicators.start, block=False) if sound else None sys.stdout.write("\rListener activated...") if stdout else None listened = recognizer.listen(source=source, timeout=timeout, phrase_time_limit=phrase_limit) playsound(sound=indicators.end, block=False) if sound else None support.flush_screen() recognized = recognizer.recognize_google(audio_data=listened) logger.info(recognized) return recognized except (UnknownValueError, RequestError, WaitTimeoutError): return except (ConnectionError, TimeoutError, requests.exceptions.RequestException, requests.exceptions.Timeout) as \ error: logger.error(error)
def listen(self) -> str: # Record Audio data = '' recognizer = Recognizer() with Microphone() as source: self.log.debug('Listening on microphone...') try: audio = recognizer.listen(source, timeout=10) except WaitTimeoutError: self.log.debug('Listen timed out.') return data # Speech recognition using Google Speech Recognition try: # Uses the default API key # To use another API key: `r.recognize_google(audio, key='GOOGLE_SPEECH_RECOGNITION_API_KEY')` data = recognizer.recognize_google(audio) self.log.debug(f'You said: "{data}"') except UnknownValueError: self.log.debug( 'Google Speech Recognition could not understand audio') except RequestError as e: self.log.error( f'Could not request results from Google Speech Recognition service: {e}' ) return str(data)
def listen(self): """ listen audio from microphone and convert to the string. :return:data """ self.recognizer = Recognizer() with Microphone() as source: self.recognizer.adjust_for_ambient_noise(source) print("I am listening you...") audio = self.recognizer.listen(source, phrase_time_limit=6) data = "" try: # Uses the default API key # To use another API key: # `r.recognize_google(audio, key="GOOGLE_SPEECH_RECOGNITION_API_KEY")` data = self.recognizer.recognize_google(audio, language="tr") print("You said : " + data) except UnknownValueError: print("Google Speech Recognition could not understand audio") return self.listen() except RequestError as exception: print("Could not request results from " "Google Speech Recognition service; {0}".format(exception)) return self.listen() return data.lower()
def __init__(self): recognizer = Recognizer() recognizer.dynamic_energy_threshold = False recognizer.energy_threshold = 1000 self.recognizer = recognizer self.microphone = Microphone() self.susi = susi try: res = requests.get('http://ip-api.com/json').json() self.susi.update_location(longitude=res['lon'], latitude=res['lat']) except ConnectionError as e: logging.error(e) self.config = json_config.connect('config.json') if self.config['hotword_engine'] == 'Snowboy': from main.hotword_engine import SnowboyDetector self.hotword_detector = SnowboyDetector() else: from main.hotword_engine import PocketSphinxDetector self.hotword_detector = PocketSphinxDetector() if self.config['wake_button'] == 'enabled': if self.config['device'] == 'RaspberryPi': from ..hardware_components import RaspberryPiWakeButton self.wake_button = RaspberryPiWakeButton() else: self.wake_button = None else: self.wake_button = None
def __init__(self): Thread.__init__(self, daemon=True); self.rec = Recognizer(); self.rec.energy_threshold=110; self.rec.pause_threshold=0.5; self.rec.operation_timeout=5; self.mic = Microphone(device_index = 2); self.answer = AnswerBot('de.txt');
def listen(self) -> None: """Listens while the microphone is open and turns the audio into readable text.""" with Microphone() as source: print('listening...') self._recognizer.adjust_for_ambient_noise(source) audio_listened = self._recognizer.listen(source) text_listened: Any = self._recognizer.recognize_google( audio_listened, ) self.text: str = text_listened.lower()
def escuchar(): print("Escuchando...") recognizer = Recognizer() microfono = Microphone() with microfono: recognizer.adjust_for_ambient_noise(microfono) recognizer.listen_in_background(microfono, callback)
def __init__(self, renderer=None): try: import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.setup(17, GPIO.OUT) GPIO.setup(27, GPIO.OUT) GPIO.setup(22, GPIO.OUT) except ImportError: print("Only available for devices with GPIO ports ") except RuntimeError: pass recognizer = Recognizer() recognizer.dynamic_energy_threshold = False recognizer.energy_threshold = 1000 self.recognizer = recognizer self.microphone = Microphone() self.susi = susi self.renderer = renderer try: res = requests.get('http://ip-api.com/json').json() self.susi.update_location( longitude=res['lon'], latitude=res['lat'], country_name=res['country'], country_code=res['countryCode']) except ConnectionError as e: logging.error(e) self.config = json_config.connect('config.json') if self.config['usage_mode'] == 'authenticated': try: susi.sign_in(email=self.config['login_credentials']['email'], password=self.config['login_credentials']['password']) except Exception: print('Some error occurred in login. Check you login details in config.json') if self.config['hotword_engine'] == 'Snowboy': from main.hotword_engine.snowboy_detector import SnowboyDetector self.hotword_detector = SnowboyDetector() else: from main.hotword_engine.sphinx_detector import PocketSphinxDetector self.hotword_detector = PocketSphinxDetector() if self.config['WakeButton'] == 'enabled': print("\nSusi has the wake button enabled") if self.config['Device'] == 'RaspberryPi': print("\nSusi runs on a RaspberryPi") from ..hardware_components import RaspberryPiWakeButton self.wake_button = RaspberryPiWakeButton() else: print("\nSusi is not running on a RaspberryPi") self.wake_button = None else: print("\nSusi has the wake button disabled") self.wake_button = None
def __init__(self): rospy.init_node("speech") self.pub = rospy.Publisher("speech_recognizer", String, latch=True, queue_size=1) self.recognizer = Recognizer() # self.recognizer.energy_threshold = 1000 # self.recognizer.pause_threshold = .7 self.microphone = Microphone()
def listen(self): try: with Microphone() as source: recognizer = Recognizer() recognizer.adjust_for_ambient_noise(source) audio = recognizer.listen(source) return recognizer.recognize_google(audio, language=self.lang).lower() except (UnknownValueError, RequestError): return ''
def __init__(self, recognizer, queue): self.recognizer = recognizer self.microphone = Microphone() self.indicator = 0 self.queue = queue self.is_actually_run = None self.err_no_net = False self.service_json = None self.load_service_json() self.service_key = 'AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw' self.for_free = False
def __init__(self, width, height): super().__init__(width, height) arcade.set_background_color(arcade.color.AMAZON) self.microphone = Microphone() self.recognizer = Recognizer() # with self.microphone as source: # self.recognizer.adjust_for_ambient_noise(source, duration=2.0) self.recognizer.energy_threshold = 5000 self.stop_listening = None
def listen(): print("Say something!") r = Recognizer() m = Microphone() with m as src: # Deal with ambient noise since microphone output is rather unpredictable r.adjust_for_ambient_noise(src) # Start listening r.listen_in_background(m, callback) # Keep listening even though main thread is blocked while True: sleep(1)
def listen(audio_queue, recognize): engine = pyttsx3.init() rate = engine.getProperty('rate') engine.setProperty('rate', rate - 40) engine.say("I am listening") engine.runAndWait() with Microphone() as source: while True: print("Слушаю Вас") audio = recognize.listen(source) audio_queue.put(audio) engine.say("Ok") engine.runAndWait()
def __init__(self, renderer=None): GPIO.setmode(GPIO.BCM) GPIO.setup(17, GPIO.OUT) GPIO.setup(27, GPIO.OUT) GPIO.setup(22, GPIO.OUT) recognizer = Recognizer() recognizer.dynamic_energy_threshold = False recognizer.energy_threshold = 1000 self.recognizer = recognizer self.microphone = Microphone() self.susi = susi self.renderer = renderer try: res = requests.get('http://ip-api.com/json').json() self.susi.update_location(longitude=res['lon'], latitude=res['lat']) except ConnectionError as e: logging.error(e) self.config = json_config.connect('config.json') if self.config['usage_mode'] == 'authenticated': try: susi.sign_in( email=self.config['login_credentials']['email'], password=self.config['login_credentials']['password']) except Exception: print( 'Some error occurred in login. Check you login details in config.json' ) if self.config['hotword_engine'] == 'Snowboy': from main.hotword_engine import SnowboyDetector self.hotword_detector = SnowboyDetector() else: from main.hotword_engine import PocketSphinxDetector self.hotword_detector = PocketSphinxDetector() if self.config['wake_button'] == 'enabled': if self.config['device'] == 'RaspberryPi': from ..hardware_components import RaspberryPiWakeButton self.wake_button = RaspberryPiWakeButton() else: self.wake_button = None else: self.wake_button = None
def myCommand(self): #listens for commands r = Recognizer() with Microphone() as source: print('Say something...') r.pause_threshold = 1 r.adjust_for_ambient_noise(source, duration=1) audio = r.listen(source) try: command = r.recognize_google(audio).lower() print('You said: ' + command + '\n') # loop back to continue to listen for commands if unrecognizable speech is received except UnknownValueError: print('....') command = speech.myCommand(self) return command
def get_audio(): rObject = Recognizer() audio = '' with Microphone() as source: print("Speak...") # recording the audio using speech recognition audio = rObject.listen(source, phrase_time_limit=5) print("Stop.") # limit 5 secs try: text = rObject.recognize_google(audio, language='en-US') print("You: ", text) return text except: chatbot_speaks("Could not understand your audio, Please try again !") return 0
def ears_setup(): p = PyAudio() count = p.get_device_count() device = [i for i in range(count) if "Logitech" in p.get_device_info_by_index(i)["name"]][0] source = Microphone(device_index=device) # yup, I'm playing with the internals of this class. source.CHUNK = 512 source.RATE = 8000 source.CHANNELS = 1 try: source.__enter__() source.stream.stop_stream() except: vprint(1, "Microphone initialization failed.") source.__exit__() return source
def robot_listen(request): wit_key = '' try: recogniser = Recognizer() microphone = Microphone() print('Listening') with microphone as source: # recogniser.adjust_for_ambient_noise(source) audio = recogniser.listen(source) return str(recogniser.recognize_wit(audio, key=wit_key, show_all=True)) except (UnknownValueError, RequestError) as e: print(e) print('\n') return str({'_text': '', 'entities': {}})
def VoiceInput(): recog = Recognizer() mic = Microphone(device_index=1) with mic: audio = recog.listen(mic) try: recognized = recog.recognize_google(audio) except UnknownValueError: Response("Try Again") with mic: audio = recog.listen(mic) recognized = recog.recognize_google(audio) except RequestError as exc: Response("Sorry my service is down") print(recognized) return (recognized)
def record_audio(ask=False): if ask: speak_electrica(ask) with Microphone() as source: print("Speak Up! I am listning..") audio = sr_engine.listen(source) audio_text = "" try: print("Now hold-on ! I'm recognising..") audio_text = sr_engine.recognize_google(audio, language="en-in") print(audio_text) return audio_text.lower() except UnknownValueError: speak_electrica("Sorry I didn't get that. kindly speak up again") say_again() except RequestError: speak_electrica("Sorry, unable to connect with engine")
def record_audio(): with Microphone() as source: r.adjust_for_ambient_noise(source, duration=0.2) audio = r.listen(source, phrase_time_limit=4) voice_data = ' ' try: voice_data = r.recognize_google(audio) except sr.UnknownValueError: # voices = engine.getProperty('voices') # engine.setProperty('voice', voices[1].id) # engine.say('Sorry I did not get that') # print('Sorry I did not get that') # engine.runAndWait() pass except sr.RequestError: # engine.say('my service is down now') pass return voice_data
from speech_recognition import Microphone print(Microphone.list_microphone_names())