CallPACK/main.py at master · thesunRider/CallPACK · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
import asyncore
import matplotlib.pyplot as plt
import zlib,socket

import numpy as np
import MFSKDemodulator, DePacketizer, MFSKSymbolDecoder, time, logging, sys
from scipy.io import wavfile
import MFSKModulator,Packetizer
import sounddevice as sd
import soundfile as sf
from scipy.io import wavfile

from thread import start_new_thread
import StringIO


#Networkrelated variables
Connection_status = False
compression = 1
packet_size = 8192
port_host = 8080

#Audio Related variables
symbol_rate = 15.625
base_freq = 1500
bits_per_symbol = 4

preamble_tones = [0,15,0,15,0,15,0,15,0,15,0,15,0,15,0,15,0,15,0,15,0,15,0,15,0,15,0,15,0,15]

#non changeables
symb_dec = ''
packet_extract = ''
handler = ''
recordable_file = "test.wav"

def zlib_compress(text):
    text_size=sys.getsizeof(text)
    compressed = zlib.compress(text)
    csize=sys.getsizeof(compressed)
    return compressed

def zlib_decompress(compressed):
    decompressed=zlib.decompress(compressed)
    return decompressed

def recover_packet(payload):
    print 'Packet recieved:',payload
    if not Connection_status:
        handler.handle_sent_data(payload)


def parse_symbol(tone):
        tone_bits = symb_dec.tone_to_bits(tone['symbol'])
        packet_extract.process_data(tone_bits)


def callback_mic(indata, frames, time, status):
    wavhndl_to_data(indata.copy())

def launch_record():
    # Make sure the file is opened before recording anything:
    with sf.SoundFile(recordable_file, mode='x', samplerate=8000,
                      channels=1) as file:
        with sd.InputStream(samplerate=8000, device=0,
                            channels=1, callback=callback_mic):
            print('#' * 80)

def wavhndl_to_data():
    global symb_dec,packet_extract
    symb_dec = MFSKSymbolDecoder.MFSKSymbolDecoder(num_tones=16, gray_coded=True)

    # De-Packetizer
    packet_extract = DePacketizer.DePacketizer(callback=recover_packet)

    #get symbol back
    demod = MFSKDemodulator.MFSKDemodulator(callback=parse_symbol)
    fs, data = wavfile.read('generated_MFSK16_packets.wav')

    # Convert to float
    if(data.dtype == np.int16):
        data = data.astype(np.float)/2**16
    elif(data.dtype == np.int32):
        data = data.astype(np.float)/2**32

    # Feed the demod the entire file.
    demod.consume(data)


def data_to_wavhndl(data):
    mod = MFSKModulator.MFSKModulator(symbol_rate = symbol_rate, tone_spacing = symbol_rate, start_silence=5, base_freq=base_freq)
    p = Packetizer.Packetizer()

    mod.modulate_symbol(preamble_tones)
    #adding msg together
    fs = p.pack_message(data)

    tx_bits = np.unpackbits(np.fromstring(fs, dtype=np.uint8))
    print(str(tx_bits))
    mod.modulate_bits(bits_per_symbol,tx_bits)

    out = mod.get_mem()
    return out

class data_recv(asyncore.dispatcher_with_send):

    def handle_read(self):
        data = self.recv(packet_size)
        modulated = data_to_wavhndl(data)
        sd.play(modulated[0],modulated[1])
        sd.wait() #wait for data to play
        print 'stat:',sd.get_status()
        if data:
            print ":Transmitting ("+str(len(modulated[0]))+") to dest"
            print "Array:",modulated
            print "data sent:",data

    def handle_close(self):
        self.close()
        Connection_status = False

    def handle_sent_data(self,data):
        self.send(data)


class proxy(asyncore.dispatcher):

    def __init__(self, host, port):
        asyncore.dispatcher.__init__(self)
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.set_reuse_addr()
        self.bind((host, port))
        self.listen(5)

    def handle_accept(self):
        global handler
        Connection_status = True
        pair = self.accept()
        if pair is not None:
            sock, addr = pair
            print 'Incoming connection from %s' % repr(addr)
            handler = data_recv(sock)

#slk = data_to_wavhndl("silence")
#sd.play(slk[0],slk[1])
#sd.wait()
#wavfile.write('generated_MFSK16_packets.wav',slk[1],slk[0])
#wavhndl_to_data()
server = proxy('localhost', port_host)
start_new_thread(launch_record,())
asyncore.loop()