def extract_packet(freqs): # listen_linux 함수에서 쓰임
freqs = freqs[::2] ## 2개씩 끊어서 가져옴
bit_chunks = [int(round((f - START_HZ) / STEP_HZ)) for f in freqs]
bit_chunks = [c for c in bit_chunks[1:] if 0 <= c < (2**BITS)]
byte_stream = bytearray(decode_bitchunks(BITS, bit_chunks))
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
if "201502049" in byte_stream:
except_byte_stream = byte_stream.replace("201502049", "")
del freqs[20:-8]
with noalsaerr():
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paFloat32,
channels=1,
rate=44100,
output=True)
for freq in freqs:
samples = (np.sin(2 * np.pi * np.arange(44100 * 0.4) * freq /
44100)).astype(np.float32)
stream.write(samples)
stream.stop_stream()
stream.close()
p.terminate()
except ReedSolomonError as e:
#pass
print("{}: {}".format(e, byte_stream))
return except_byte_stream
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,
alsaaudio.PCM_NORMAL,
device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
#print(byte_stream)
if "201502091" in byte_stream:
# remove studentId
new_byteStream = byte_stream.replace('201502091 ',
'').strip()
display(new_byteStream)
#print(new_byteStream)
#print(type(new_byteStream)
new_byteStream = RSCodec(FEC_BYTES).encode(new_byteStream)
#print(type(new_byteStream))--> bytearray
play(new_byteStream)
# call main function
#new_byteStream = new_byteStream.encode("utf-8")
#new_byteStream = RSCodec(FEC_BYTES).encode(new_byteStream)
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL)
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
print("original code", byte_stream)
if match_num(byte_stream) == False:
break
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
print(byte_stream)
byte_stream = byte_stream.replace("201702087", "")
display(byte_stream)
display("")
sin_freq = []
byte_stream = byte_stream.encode("utf-8")
byte_stream = RSCodec(FEC_BYTES).encode(byte_stream)
sin_freq = make_freq(byte_stream, sin_freq)
print(sin_freq)
make_sound(sin_freq)
except ReedSolomonError as e:
print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,
alsaaudio.PCM_NORMAL,
device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
#print(dom)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
# change to str to use find(), replace()
byte_stream = str(byte_stream)
# check student number
if (byte_stream.find("201502111") != -1):
# delete student number
byte_stream = byte_stream.replace("201502111", "")
display(byte_stream)
display("")
# play sound without student number
play_linux(byte_stream, interval)
except ReedSolomonError as e:
print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,
alsaaudio.PCM_NORMAL,
device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
if ID in byte_stream:
global result_stream
#print(byte_stream)
result_stream = byte_stream.replace(ID, '')
result_stream = result_stream.strip()
rs = RSCodec(4)
result_stream = rs.encode(result_stream)
print(result_stream)
play_linux()
display(byte_stream)
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream, real_output = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
if byte_stream.find("201604148") != -1:
byte_stream = byte_stream.replace("201604148", "",1)
stream_len = len(byte_stream)
stream_len -=1
display(byte_stream)
real_output = real_output[0:stream_len*2]
make_sound(real_output)
else:
pass
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, device="default")
mic.setchannels(1) # chanel 1 use
mic.setrate(44100) # frame_rate 44100/s
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames) #
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
print("end")
byte_stream = extract_packet(packet)
try: # 4 bytes
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream) # reed solo error check
byte_stream = byte_stream.decode("utf-8")
if STUDENT_ID in byte_stream:
byte_stream = byte_stream.replace(STUDENT_ID, "").strip()
display(byte_stream)
byte_stream = RSCodec(FEC_BYTES).encode(byte_stream)
sleep(1)
speaking_linux(byte_stream)
sleep(1)
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
print("start HandShake")
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,
alsaaudio.PCM_NORMAL,
device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
if '201704148' in byte_stream:
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paFloat32,
channels=1,
rate=44100,
output=True)
data_to_play = byte_stream.replace('201704148', '')
display(data_to_play)
sleep(1)
data_to_play = RSCodec(FEC_BYTES).encode(data_to_play)
frequencies = get_frequencies(BITS, data_to_play)
for freq in frequencies:
sample = (np.sin(
2 * np.pi * np.arange(SAMPLE_RATE * DURATION) *
freq / SAMPLE_RATE)).astype(np.float32).tobytes()
'''
increment = 2 * np.pi * freq / SAMPLE_RATE
angle = 0
for i in range(SAMPLE_SIZE):
sample.append(np.sin(angle).astype(np.float32))
angle += increment
'''
stream.write(sample)
stream.stop_stream()
stream.close()
p.terminate()
except ReedSolomonError as e:
pass
# print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
#print(dom)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
#print(byte_stream)
byte_stream = byte_stream.decode("utf-8")
#print(byte_stream)
if '201502101 ' in byte_stream:
byte_stream = byte_stream.replace("201502101 ","")
display(byte_stream)
elif '201502101' in byte_stream:
byte_stream = byte_stream.replace("201502101","")
display(byte_stream)
else :
break
#print(int(ord(byte_stream[1])))
byte_stream = byte_stream.encode("utf-8")
byte_stream = RSCodec(FEC_BYTES).encode(byte_stream)
#print(byte_stream[1])
stream1 = []
stream1.append(HANDSHAKE_START_HZ)
for i in range(len(byte_stream)):
stream1.append(((byte_stream[i] >> 4)*STEP_HZ)+START_HZ)
stream1.append(((byte_stream[i] & 0xf)*STEP_HZ)+START_HZ)
stream1.append(HANDSHAKE_END_HZ)
with noalsaerr():
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paFloat32, channels=1, rate =44100, output = True)
duration = 0.5
for i in range(len(stream1)):
print(stream1[i])
samples = (np.sin(2*np.pi*np.arange(44100*duration)*(stream1[i]/44100))).astype(np.float32)
stream.write(samples)
stream.stop_stream()
stream.close()
p.terminate()
except ReedSolomonError as e:
pass
# print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,
alsaaudio.PCM_NORMAL,
device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
#display(byte_stream)
print("---------------------------------------------")
#초기에 상태 설정
state = False
#입력 받은 데이터 내부에 학번 정보 검사
if '201502012' in byte_stream:
state = True
#데이터에 학번 정보 있으면 실행
if state:
#학번에 대한 데이터를 제거하고 data만 남긴다.
byte_stream_data = byte_stream.replace('201502012', '')
print("데이터 추출", byte_stream_data)
#다시 인코드 시킨다.
byte_stream_data = byte_stream_data.encode("utf-8")
#앞뒤의 공백을 제거
byte_stream_data = byte_stream_data.strip()
print("encode : ", byte_stream_data)
#빈 배열 생성
data = []
for i in byte_stream_data:
#1바이트를 4비트씩 분해해서 data 배열에 Hz로 계산하여 삽입
front = i >> 4
back = i & 0x0f
front = front * STEP_HZ + START_HZ
back = back * STEP_HZ + START_HZ
data.append(front)
data.append(back)
#Hz 정보 출력
print("data_Hz : ", data)
#pyaudio 객체 생성
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paFloat32,
channels=1,
rate=44100,
output=True)
#Hz를 따라서 소리 출력
for freq in data:
#Hz를 정현파로 만든다.
examples = (np.sin(2 * np.pi * np.arange(44100 * 1.1) *
freq / 44100)).astype(np.float32)
print("freq", freq)
#소리를 출력한다.
stream.write(examples)
#초기에 입력받은 값 중에 학번을 제거한 데이터만 출력
byte_stream_data = byte_stream_data.decode("utf-8")
display(byte_stream_data)
else:
#학번이 일치하지 않으면 오류 문구 출력
print("Match Error")
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
#print(dom)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
temp_list=list(byte_stream)
error_byte=temp_list[-4:]#back 4 error byte
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
byte_stream=str(byte_stream)
display(byte_stream)
if byte_stream.find('201701198')!=-1:
byte_stream = byte_stream.replace('201701198' ,'')#remove my num
byte_stream = list(byte_stream) # change to list
byte_stream_dec=[]
for i in byte_stream:
byte_stream_dec.append(ord(i))
# -------------------------
waveform_list = []
byte_stream_dec += error_byte
freq_hz = back_to_hz(byte_stream_dec)
# Samples per second
sps = 44100
# how long
# duration_s = 0.1 * len(freq_hz) # 201701198 --> play twice(9*2)
duration_s = 0.1
each_sample_number = np.arange(0, duration_s* sps)
#print(freq_hz)
for i in freq_hz:
waveform = np.sin(2 * np.pi * i * each_sample_number/sps).astype(np.float32)
waveform_list = np.append(waveform_list, waveform)
sd.play(waveform_list, sps)
time.sleep(duration_s*len(freq_hz)) # important to make perfectly fit
sd.stop()
# --------------------------
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,
alsaaudio.PCM_NORMAL,
device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
# for n in packet:
# print(abs(n))
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
#add code
ats = len(at) - 4 #is last 4 code. this not text section
for n in range(0, 4):
last.append(at[ats + n])
#------------------------------------
if "201502059" in byte_stream: #add code
print("yes")
first = [ord(n) for n in byte_stream]
first = first + last
print(first)
print(byte_stream)
text = byte_stream.replace("201502059", "")
display(text)
a = [ord(n) for n in text]
#print(a)
#print(last)
a = a + last
del last[:]
#print(a)
b = list()
for n in a:
b.append(n // 16)
b.append(n % 16)
#print(b)
rdom = [int((f * STEP_HZ) + START_HZ) for f in b]
#print(rdom)
time = numpy.arange(0, 1, 1 / 20000)
pi = numpy.pi
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paFloat32,
channels=1,
rate=44100,
output=True)
for n in range(int((len(b) / 2))):
print(b[n * 2], b[n * 2 + 1])
print("freq:", rdom[n * 2])
print("freq:", rdom[n * 2 + 1])
sample = numpy.sin(2 * pi * rdom[n * 2] / 2 *
time).astype(numpy.float32)
#print(sample)
stream.write(sample)
sample = numpy.sin(2 * pi * rdom[n * 2 + 1] / 2 *
time).astype(numpy.float32)
#print(sample)
stream.write(sample)
else:
print("no")
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
#plus
if byte_stream.find("201702002") != -1 :
byte_stream = byte_stream.replace("201702002", "")
display(byte_stream)
ascii_stream = []
i = 0
while i<len(byte_stream):
ord_byte = ord(byte_stream[i])
ascii_stream.append(ord_byte)
i+=1
split_ascii = []
i = 0
while i<len(ascii_stream):
split_ascii.append(int(ascii_stream[i]/16))
split_ascii.append(ascii_stream[i]%16)
i+=1
#print("split_ascii :", split_ascii)
new_freqs = []
i = 0
while i<len(split_ascii):
new_freqs.append(START_HZ+STEP_HZ*split_ascii[i])
i+=1
print(new_freqs)
p=pyaudio.PyAudio()
stream = p.open(format = pyaudio.paFloat32, channels=1, rate=44100, output=True)
for i in new_freqs :
sinx = np.arange(44100)
siny = (np.sin((2.0*np.pi*sinx)*(i/44100))).astype(np.float32)
stream.write(siny.tobytes())
stream.close()
p.terminate()
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
