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, 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)
    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):
            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