def main():
import time
import datetime
from voice_engine.source import Source
from voice_engine.channel_picker import ChannelPicker
from voice_engine.file_sink import FileSink
src = Source(channels=2, rate=48000, frames_size=48000)
chx = ChannelPicker(channels=src.channels, pick=0)
thd = THD(1000, src.rate)
filename = '2.94dB1KHz.' + datetime.datetime.now().strftime("%Y%m%d.%H:%M:%S") + '.wav'
sink = FileSink(filename, channels=src.channels, rate=src.rate)
src.link(sink)
src.pipeline(chx, thd)
src.pipeline_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
def main():
logging.basicConfig(level=logging.DEBUG)
src = Source(rate=16000)
ns = NS(rate=16000, channels=1)
kws = KWS(model='alexa')
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.pipeline(ns, kws, alexa)
def on_detected(keyword):
logging.info('detected {}'.format(keyword))
alexa.listen()
kws.set_callback(on_detected)
is_quit = []
def signal_handler(signal, frame):
is_quit.append(True)
print('Quit')
signal.signal(signal.SIGINT, signal_handler)
src.pipeline_start()
while not is_quit:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
def main():
src = Source(rate=16000, channels=2)
ch1 = ChannelPicker(channels=2, pick=1)
ns = NS(rate=16000, channels=1)
kws = KWS(model='snowboy', sensitivity=0.6, verbose=True)
src.pipeline(ch1, ns, kws)
def on_detected(keyword):
print('detected {}'.format(keyword))
kws.set_callback(on_detected)
src.pipeline_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
# wait a second to allow other threads to exit
time.sleep(1)
def main():
src = Source(rate=16000, frames_size=320, channels=8)
ec = EC(channels=src.channels, capture=0, playback=7)
ns = NS(rate=src.rate, channels=1)
kws = KWS()
# data flow between elements
# ---------------------------
# src -> ec -> ns -> kws
src.pipeline(ec, ns, kws)
def on_detected(keyword):
led.toggle()
print('detected {}'.format(keyword))
kws.on_detected = 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()
# wait a second to allow other threads to exit
time.sleep(1)
led.off()
def main():
import time
from voice_engine.source import Source
from voice_engine.kws import KWS
src = Source(rate=16000, channels=2, frames_size=1600)
route = Route(channels=src.channels)
kws = []
def gen(channel):
def on_detected(keyword):
print('detected at channel {}'.format(channel))
return on_detected
for ch in range(src.channels):
k = KWS(sensitivity=0.5)
k.set_callback(gen(ch))
kws.append(k)
src.pipeline(route, kws)
src.pipeline_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
def main():
import time
from voice_engine.channel_picker import ChannelPicker
from voice_engine.kws import KWS
from voice_engine.source import Source
src = Source(channels=2)
ch0 = ChannelPicker(channels=src.channels, pick=0)
kws = KWS(model='snowboy', sensitivity=0.7)
bing = Bing(BING_KEY)
src.pipeline(ch0, kws, bing)
def on_detected(keyword):
print('detected {}'.format(keyword))
bing.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)
ns = NS(rate=16000, channels=1)
kws = KWS(model='alexa')
alexa = Alexa()
src.pipeline(ns, kws, alexa)
def on_detected(keyword):
logging.info('detected {}'.format(keyword))
alexa.listen()
kws.set_callback(on_detected)
src.pipeline_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
def main():
src = Source(rate=16000, frames_size=320, channels=8)
ch0 = ChannelPicker(channels=src.channels, pick=0)
kws = KWS(model='snowboy', sensitivity=0.5)
doa = DOA(rate=src.rate, chunks=20)
src.pipeline(ch0, kws)
src.link(doa)
def on_detected(keyword):
direction = doa.get_direction()
print('detected {} at direction {}'.format(keyword, direction))
pixel_ring.wakeup(direction)
time.sleep(2)
pixel_ring.off()
kws.on_detected = 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()
def main():
src = Source(rate=16000, channels=6, device_name='hw:1')
route = Route(channels=src.channels)
def get_kws_callback(channel):
def on_detected(keyword):
print('detected @ {}'.format(channel))
return on_detected
kws = []
for channel in range(2):
k = KWS(model='snowboy', sensitivity=0.6)
k.on_detected = get_kws_callback(channel)
kws.append(k)
sink = FileSink('c6.wav', rate=src.rate, channels=src.channels)
src.pipeline(route, kws)
src.link(sink)
src.recursive_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.recursive_stop()
def main():
src = Source(rate=16000, channels=8)
ch1 = ChannelPicker(channels=8, pick=1)
kws = KWS()
filename = '4.kws.' + datetime.datetime.now().strftime(
"%Y%m%d.%H:%M:%S") + '.wav'
sink = FileSink(filename, channels=src.channels, rate=src.rate)
src.link(sink)
src.pipeline(ch1, kws)
def on_detected(keyword):
print('detected {}'.format(keyword))
kws.set_callback(on_detected)
src.recursive_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.recursive_stop()
def main():
import time
from voice_engine.source import Source
src = Source(rate=48000, channels=2, frames_size=4800)
dbfs = DBFS(channels=src.channels)
src.pipeline(dbfs)
src.pipeline_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
def main():
from voice_engine.source import Source
src = Source(rate=16000, channels=1)
assistant = Mirror()
src.pipeline(assistant)
src.pipeline_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
def main():
src = Source(rate=16000, frames_size=160, channels=2)
ch0 = ChannelPicker(channels=src.channels, pick=0)
ns = NS(rate=src.rate, channels=1)
kws = KWS()
doa = DOA(rate=16000, chunks=50)
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
# data flow between elements
# ---------------------------
# src -> ns -> kws -> alexa
# \
# doa
src.pipeline(ch0, ns, kws, alexa)
src.link(doa)
def on_detected(keyword):
direction = doa.get_direction()
print('detected {} at direction {}'.format(keyword, direction))
alexa.listen()
pixel_ring.wakeup(direction)
kws.on_detected = 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()
pixel_ring.off()
# wait a second to allow other threads to exit
time.sleep(1)
def main():
import time
from voice_engine.source import Source
src = Source(rate=16000, channels=2, frames_size=1600)
ec = EC(channels=src.channels, capture=0, playback=1)
src.pipeline(ec)
src.pipeline_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
def main():
src = Source(rate=16000, frames_size=320, channels=8)
ec = EC(channels=src.channels, capture=0, playback=7)
ns = NS(rate=src.rate, channels=1)
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.pipeline(ec, ns, kws, alexa)
src.link(doa)
def on_detected(keyword):
direction = doa.get_direction()
print('detected {} at direction {}'.format(keyword, direction))
alexa.listen()
pixel_ring.wakeup(direction)
kws.on_detected = 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()
pixel_ring.off()
# wait a second to allow other threads to exit
time.sleep(1)
def main():
src = Source(rate=16000, channels=1, device_name="default")
kws = KWS(model='computer', sensitivity=0.6, verbose=True)
src.pipeline(kws)
def on_detected(keyword):
print('\ndetected {}'.format(keyword))
kws.set_callback(on_detected)
src.pipeline_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
def main():
src = Source(rate=16000, frames_size=320, channels=8)
ec = EC(channels=src.channels, capture=0, playback=7)
ns = NS(rate=src.rate, channels=1)
kws = KWS()
doa = DOA(rate=16000, chunks=20)
# data flow between elements
# ---------------------------
# src -> ec -> ns -> kws
# \
# doa
src.pipeline(ec, ns, kws)
src.link(doa)
def on_detected(keyword):
direction = doa.get_direction()
print('detected {} at direction {}'.format(keyword, direction))
pixel_ring.wakeup(direction)
kws.on_detected = 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()
pixel_ring.off()
# wait a second to allow other threads to exit
time.sleep(1)
def main():
src = Source(rate=16000, channels=8, frames_size=1600)
ec = EC(channels=src.channels, capture=0, playback=6)
kws = KWS(sensitivity=0.7)
def on_detected(keyword):
global count
count += 1
print('detected {}'.format(keyword))
kws.on_detected = on_detected
src.pipeline(ec, kws)
src.pipeline_start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
print('total = {}'.format(count))
src.pipeline_stop()
def main():
src = Source(rate=16000, frames_size=320, channels=8)
ch0 = ChannelPicker(channels=src.channels, pick=0)
kws = KWS(model='alexa', sensitivity=0.8)
doa = DOA(rate=src.rate, 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.pipeline(ch0, kws, alexa)
src.link(doa)
def on_detected(keyword):
direction = doa.get_direction()
print('detected {} at direction {}'.format(keyword, direction))
alexa.listen()
pixel_ring.wakeup(direction)
kws.on_detected = 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()
def main():
src = Source(rate=16000, frames_size=320, channels=8)
ec = EC(channels=src.channels, capture=0, playback=7)
# ns = NS(rate=src.rate, channels=1)
kws = KWS(model='alexa')
alexa = Alexa()
alexa.state_listener.on_listening = led.on
alexa.state_listener.on_finished = led.off
#src.pipeline(ec, ns, kws, alexa)
src.pipeline(ec, kws, alexa)
def on_detected(keyword):
led.on()
print('detected {}'.format(keyword))
alexa.listen()
kws.on_detected = 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()
led.off()
# wait a second to allow other threads to exit
time.sleep(1)
def main():
from voice_engine.source import Source
from voice_engine.ns import NS
from bf import BF
src = Source(rate=16000, channels=8)
bf = BF()
ns = NS()
assistant = Mirror()
src.pipeline(bf, ns, assistant)
ns.link(alexa)
src.pipeline_start()
led.off()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
src.pipeline_stop()
if __name__ == "__main__":
quit_event = threading.Event()
client_secret = 'INSERT YOUR CLIENT SECRET'
auth_client = AzureAuthClient(client_secret)
# src = Source(rate=16000, frames_size=160)
src = Source(channels=8, rate=16000, frames_size=160)
doa = DOA(channels=8)
audio_buffer = AudioBuffer()
src.pipeline(doa, audio_buffer)
player = Player()
# Translate from this language. The language must match the source audio.
# Supported languages are given by the 'speech' scope of the supported languages API.
translate_from = 'en-US'
# Translate to this language.
# Supported languages are given by the 'text' scope of the supported languages API.
translate_to = 'zh-HANS'
# Features requested by the client.
features = "Partial,TextToSpeech"
# Transcription results will be saved into a new folder in the current directory
output_folder = os.path.join(os.getcwd(), uuid.uuid4().hex)
def main():
src = Source(rate=48000,
channels=4,
device_name='voicen',
bits_per_sample=32)
decoder = Decoder(channels=src.channels, select=0, bits_per_sample=32)
def on_data(data):
print([c for c in data])
ssid_length = data[0]
ssid = data[1:ssid_length + 1].tostring().decode('utf-8')
password_length = data[ssid_length + 1]
password = data[ssid_length + 2:ssid_length + password_length +
2].tostring().decode('utf-8')
# print(u'SSID: {}\nPassword: {}'.format(ssid, password))
cmd = 'mosquitto_pub -t /voicen/hey_wifi -m 2'
os.system(cmd)
if os.system('which nmcli >/dev/null') != 0:
print('nmcli is not found')
return
cmd = 'nmcli device wifi rescan'
os.system(cmd)
cmd = u'nmcli connection delete "{}"'.format(ssid)
os.system(cmd)
cmd = u'nmcli device wifi connect "{}" password "{}"'.format(
ssid, password)
if os.system(cmd) != 0:
print('Failed to connect the Wi-Fi network')
return
print('Wi-Fi is connected')
ip_info = get_ip_info()
if not ip_info:
print('Not find any IP address')
return
print(ip_info)
decoder.done = True
cmd = 'mosquitto_pub -t /voicen/hey_wifi -m 3'
os.system(cmd)
channel = int((data[-1] << 8) + data[-2])
payload = json.dumps({'id': channel, 'data': ip_info.decode()})
message = encrypt(channel, data, payload.encode())
if os.system('which mosquitto_pub >/dev/null') != 0:
print('mosquitto_pub is not found')
cmd = 'mosquitto_pub -h q.voicen.io -u mqtt -P mqtt -q 1 -t "/voicen/hey_wifi/{}" -m "{}"'.format(
channel, message)
print(cmd)
for _ in range(3):
if os.system(cmd) == 0:
break
else:
print('Failed to send message to the web page')
print('Done')
cmd = 'mosquitto_pub -t /voicen/hey_wifi -m 4'
os.system(cmd)
decoder.on_data = on_data
src.pipeline(decoder)
src.pipeline_start()
while not decoder.done:
try:
time.sleep(1)
except KeyboardInterrupt:
print('exit')
break
src.pipeline_stop()
def CtrlC(signum, frame):
os.kill(os.getpid(), signal.SIGKILL)
'''
main start ...
'''
if __name__ == "__main__":
try:
src = Source(channels=8)
ch0 = ChannelPicker(channels=src.channels, pick=0)
ns = NS()
bing = Bing(BING_KEY)
src.pipeline(ch0, ns, bing)
bing_api_call()
signal.signal(signal.SIGINT, CtrlC)
signal.signal(signal.SIGTERM, CtrlC)
thread_key = threading.Thread(target=key_hander, args=(1, ))
thread_play = threading.Thread(target=pre_play, args=(1, ))
thread_key.setDaemon(True)
thread_play.setDaemon(True)
thread_key.start()
thread_play.start()
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setWindowTitle('Audio Measuring Experiment')
self.resize(800, 500)
self.cwidget = QWidget()
self.setCentralWidget(self.cwidget)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.cwidget.setLayout(layout)
self.plotwidget = pg.PlotWidget()
layout.addWidget(self.plotwidget)
self.plotwidget.setTitle(title="press 'space' to freeze/resume")
self.plot = self.plotwidget.plot()
self.plot.setPen((0, 255, 0))
self.ff = pg.TextItem('fundamental frequency', anchor=(0, 0))
self.plotwidget.addItem(self.ff)
self.ff.setPos(100, 0)
self.arrow = pg.ArrowItem(pos=(100, 0), angle=-45)
self.plotwidget.addItem(self.arrow)
plotitem = self.plotwidget.getPlotItem()
# plotitem.hideAxis('left')
# plotitem.hideAxis('bottom')
self.freeze = False
self.timer = pg.QtCore.QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(50)
self.src = Source(rate=48000, frames_size=4800)
chx = ChannelPicker(channels=self.src.channels, pick=0)
thd = THD(1000, self.src.rate)
filename = '2.94dB1KHz.' + datetime.datetime.now().strftime(
"%Y%m%d.%H:%M:%S") + '.wav'
sink = FileSink(filename,
channels=self.src.channels,
rate=self.src.rate)
def on_data(d):
global data
data = d
thd.on_data = on_data
self.src.link(sink)
self.src.pipeline(thd)
self.src.pipeline_start()
def update(self):
global data
if not self.freeze and data is not None:
self.plot.setData(data)
self.arrow.setPos(100, data[100])
self.ff.setPos(100, 0)
self.ff.setText(str(data[100]))
def keyPressEvent(self, event):
key = event.key()
if key == Qt.Key_Space:
self.freeze = not self.freeze
elif key == Qt.Key_Escape:
self.plotwidget.enableAutoRange()
return True
def closeEvent(self, event):
self.src.pipeline_start()
event.accept()
import time
import signal
from voice_engine.source import Source
from voice_engine.kws import KWS
from alexa import Alexa
import logging
logging.basicConfig(level=logging.WARNING)
src = Source(rate=16000)
kws = KWS(model='alexa', sensitivity=0.5)
alexa = Alexa()
src.pipeline(kws, alexa)
def on_detected(keyword):
print('detected {}'.format(keyword))
alexa.listen()
kws.set_callback(on_detected)
is_quit = []
def signal_handler(signal, frame):
print('Quit')
is_quit.append(True)
def main():
src = Source(rate=16000, frames_size=320, channels=8)
ch0 = ChannelPicker(channels=src.channels, pick=0)
kws = KWS(model='alexa', sensitivity=0.8)
pws = KWS(model='/usr/share/respeaker/snowboy/resources/nivi.pmdl')
def pwstest():
print('calling Personal function')
exit()
doa = DOA(rate=src.rate, 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.pipeline(ch0, kws, alexa)
src.pipeline(ch0, pws, doa)
src.link(doa)
def on_detected(keyword):
print('ALEXA Testing fuction')
direction = doa.get_direction()
print('detected {} at direction {}'.format(keyword, direction))
alexa.listen()
pixel_ring.wakeup(direction)
print('afteralexa')
kws.on_detected = on_detected
#pws.on_detected = on_detected
print('afterkws before pws')
#is_quit = []
def on_detected(keyword):
direction = doa.get_direction()
print('PWS Testing')
print('detected {} at direction {}'.format(keyword, direction))
pwstest()
#alexa.listen()
pixel_ring.wakeup(direction)
print('Personal function working')
pws.on_detected = 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()
