def main():
print("--- creating connection")
CONN = create_connection((DOMAIN, PORT), 3)
# listen for messages
msg_receiver = receiver.receiver(CONN, FILENAME)
msg_receiver.start()
print("--- notifying peer")
peer_notify(CONN)
while True:
time.sleep(1)
def handle_accept(self):
conn, addr = self.accept()
print '--- Connect --- '
print self.TCP_connects
print "key (addr) :", addr
key = addr
TCP_Forwarder.TCP_connects[key] = {}.fromkeys(
['sender', 'receiver', 'attribute'])
TCP_Forwarder.TCP_connects[key]["attribute"] = {}
sender(receiver(conn, key, self), self.remoteip, self.remoteport, key,
self)
def main():
print("--- creating connection")
CONN = create_connection((DOMAIN, PORT), 3)
# listen for messages
msg_receiver = receiver.receiver(CONN, FILENAME)
msg_receiver.start()
# test normal functions
test_server(CONN)
print("--- closing connection")
CONN.close()
sys.exit()
def __init__(self, signal, algorythm, now):
print("String: ")
napis = ""
print(type(signal))
for x in range(len(signal)):
napis += str(signal[x])
print(napis)
if (algorythm == "AES"):
napis = ""
for x in range(len(signal)):
napis += str(signal[x])
if (signal[x] == 0):
napis += "0"
print(napis)
print(type(napis))
key = random.randint(0x00, 0xFF)
cipher = AES2.AES(key)
print(type(napis))
encrypted = cipher.encrypt(napis)
decrypted = cipher.decrypt(encrypted)
print(decrypted)
else:
pure_disrupted = distrupter.distruption2(
signal,
algorythm) # zaklocenie sygnalu wysylanego bez scramblera
scrambled = scrambler.scramble(
signal, algorythm) # zescramblowanie sygnalu
tab1 = list(receiver.signalhistogram(scrambled).keys())
tab2 = list(receiver.signalhistogram(scrambled).values())
scrambled_disrupted = distrupter.distruption(
scrambled,
algorythm) # zaklocenie sygnalu wysylanego ze scramblerem
descrambled = descrambler.descramble(
scrambled_disrupted, algorythm
) # odsramblowanie sygnalu zakloconego wysylanego ze scramblerem
receiver.receiver(
signal, pure_disrupted, descrambled, algorythm, scrambled,
scrambled_disrupted, tab1, tab2,
now) # przekazanie sygnalow do programu odbiorczego
async def main(cfg):
logging.basicConfig(filename=cfg["LOGFILE"],
level=cfg["LOGLEVEL"],
format=cfg["LOG_FORMAT"],
datefmt=cfg["LOG_DATEFMT"])
try:
tasks = asyncio.gather(asyncio.create_task(receiver(cfg)),
asyncio.create_task(sender(cfg)))
await tasks
except (KeyboardInterrupt, asyncio.CancelledError):
tasks.cancel()
def talker(prog, sour, dest, action, args, data):
producer.response(prog, dest, sour, 'response', (), 'connected')
rcdr = recorder.recoder()
rcdrthr = Process(target=rcdr.recoder, args=(dest, sour, user,), daemon=True)
rcdrthr.start()
receiver = recv.receiver()
receiver.play(dest, sour, 'pi', )
#rcdrthr.terminate()
#rcdrthr.join()
print('...........................')
return
def main():
print("1)Caesar\n2)Multiplication\n3)affine\n4)ubrytelig\n5)rsa\n")
which_alg = input(": ")
if which_alg == '1':
cy_alg = caesar()
elif which_alg == '2':
cy_alg = multiplikasjons_cypher()
elif which_alg == '3':
cy_alg = affine()
elif which_alg == '4':
cy_alg = ubrytelige()
else:
cy_alg = rsa()
send = sender(cy_alg)
receiv = receiver(cy_alg)
hack = hacker(cy_alg)
while True:
choos_key = input(
"Choose 1 to inter your key, else choose other number: ")
if choos_key == '1':
key = input("your key is: ")
if which_alg == '4':
send.set_receiver(cy_alg, receiv, key)
elif which_alg == '3':
key2 = input("your second key is: ")
send.set_receiver(cy_alg, receiv, (int(key),int(key2)))
else:
send.set_receiver(cy_alg, receiv, int(key))
else:
send.set_receiver(cy_alg, receiv)
receiv.set_sender(cy_alg, send)
my_text = input("Your Text: ")
code = send.operate_cypher(my_text)
print("Cypher: " + code)
decoded_code = receiv.operate_cypher(code)
print("after: " + decoded_code)
verify = cy_alg.verify(my_text, decoded_code)
if verify:
break
else:
print("Repeat!\n")
print("hack: {} ".format(hack.hack(code)))
from sender import sender
from receiver import receiver
sender('text', 'text1', 'text2')
sender('text1', 'text', 'text2')
receiver('text2')
import math
import receiver #module of a receiver function
t = receiver.delay() #download time of delay and return in an integer
sp = receiver.receiver() #download initial coordinates and return in a tuple
a = sp[0]
b = sp[1]
c = sp[2] #assign tuple (sp) values to variables a, b and c
coordinates = receiver.location(
) #download current coordinates and return in a tuple
x = coordinates[0]
y = coordinates[1]
z = coordinates[2] #assign tuple (coordinates) values to variables x, y and z
print(x, y, z)
speed = math.sqrt((a - x)**2 + (b - y)**2 +
(c - z)**2) / t #calculate speed (units per seconds)
print(speed)
def listen_requests(tc, ts, chunks):
rx_ip = '[email protected]'
rx = receiver(channels, chunks, ts, tc, rx_ip, 'received-wavfile.wav')
print('beginning to receive')
rx.start()
# it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # If you have a applicable agreement with GreenSocs Ltd, the terms of that # agreement prevail. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA # # ENDLICENSETEXT import gs from sender import sender from receiver import receiver # Describe the system sender1 = sender() receiver1 = receiver() # Start! gs.start()
from receiver import receiver
if __name__ == "__main__":
receiver = receiver()
receiver.keep_listening(10)
group_delay = (g.size - 1) // 2
# s_BB=s_BB[group_delay:-group_delay]
#spec=sender_.anti_image(s_BB)
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Plot.konstellation(s_BB,'Signal from sender')
###Kommentar: Nullpunkt wegen Filterdelay
#Plot.timesignal(s_BB,"Baseband signal")
#Plot.spectrum(s_BB,"Baseband spectrum")
#!!Image filterung
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#with Filter
receiver_=receiver(H,sender_,SNR_dB,filter_,mpsk_map,s_BB)
r=receiver_.r
rr=receiver_.r
#Plot.timesignal(rr,"nach Kanal")
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Plot.konstellation(r,'Signal after channel')
#Plot.timesignal(r[:,0],'Signal after channel')
#Plot.spectrum(r,'Signal after channel')
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
# off=np.exp(1j*2*np.pi*f_off*np.arange(r.shape[0])*T/filter_.n_up)
# r_off_ft=r*np.repeat(off,RA).reshape([-1,RA])*np.exp(1j*phi_off)
#
#
class Controller(object):
"""A controller which implements drag-and-drop bahavior on connected view
objects. Subclasses may override the drag_start, drag_end, pos, and
set_pos methods"""
_view = receiver()
_dragging = None
_canvas = None
_cursor = None
_ptr_within = False
_last_click = None
_mousedown = None
_last_event = None
def __init__(self, view=None):
object.__init__(self)
self._view = view
## convenience functions
def from_event(self, event):
"""returns the coordinates of an event"""
return Point(*self._canvas.convert_from_pixels(event.x, event.y))
def from_item_event(self, item, event):
return Point(*self._canvas.convert_from_item_space(
item, *self.from_event(event)))
def pos(self, item):
bounds = item.get_bounds()
return Point(bounds.x1, bounds.y1)
def size(self, item):
bounds = item.get_bounds()
return Point(bounds.x2, bounds.y2) - Point(bounds.x1, bounds.y1)
def center(self, item):
return self.pos(item) + self.size(item) // 2
def last_xy(self):
return self.transform(self._mousedown +
self.from_event(self._last_event))
## signal handlers
@handler(_view, "enter_notify_event")
def enter_notify_event(self, item, target, event):
self._last_event = event
if self._cursor:
event.window.set_cursor(self._cursor)
self.enter(item, target)
self._ptr_within = True
return True
@handler(_view, "leave_notify_event")
def leave_notify_event(self, item, target, event):
self._last_event = event
self._ptr_within = False
if not self._dragging:
self.leave(item, target)
return True
@handler(_view, "button_press_event")
def button_press_event(self, item, target, event):
self._last_event = event
if not self._canvas:
self._canvas = item.get_canvas()
self._mousedown = self.pos(item) - self.transform(
self.from_item_event(item, event))
self._dragging = target
self._drag_start(item, target, event)
return True
@handler(_view, "motion_notify_event")
def motion_notify_event(self, item, target, event):
self._last_event = event
if self._dragging:
self.set_pos(
self._dragging,
self.transform(self._mousedown +
self.from_item_event(item, event)))
return True
return False
@handler(_view, "button_release_event")
def button_release_event(self, item, target, event):
self._last_event = event
self._drag_end(item, self._dragging, event)
self._dragging = None
return True
## internal callbacks
def _drag_start(self, item, target, event):
self.drag_start()
def _drag_end(self, item, target, event):
self.drag_end()
if self._ptr_within:
point = self.from_item_event(item, event)
if self._last_click and (event.time - self._last_click < 400):
self.double_click(point)
else:
self.click(point)
self._last_click = event.time
## protected interface for subclasses
def click(self, pos):
pass
def double_click(self, pos):
pass
def drag_start(self):
pass
def drag_end(self):
pass
def set_pos(self, obj, pos):
x, y = pos
self._view.set_simple_transform(x, y, 1.0, 0.0)
def transform(self, pos):
return pos
def enter(self, item, target):
pass
def leave(self, item, target):
pass
def sm(SNR_dB,N,N_known,threshold):
#def sm(SNR_dB,n):
#number of sender antennas
SA=4
#number of receiver antennas
RA=4
#data bits modulation order (BPSK)
M=2
mpsk_map=np.array([1,-1])
#mpsk_map =1/np.sqrt(2) * np.array([1+1j, -1+1j, 1-1j, -1-1j], dtype=complex)
#symbol duration
T=1*1e-6
#Frequency offset
#f_off=np.random.randint(-0.001/T,0.001/T)
f_off=np.random.randint(0.01/T,0.05/T)
# N_known=int(1//T//f_off/n)
# N=10*N_known
#phase offset
phi_off=np.random.random()*2*np.pi
#number of Index bits per symbol
Ni=int(np.log2(SA))
#number of Data bits per symbol
Nd=int(np.log2(M))
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Upsampling rate
n_up=1
# RRC Filter (L=K * sps + 1, sps, t_symbol, rho)
filter_=rrcfilter(8*n_up+1,n_up , 1,0.5)
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Channel matrix
H=1/np.sqrt(2)*((np.random.randn(RA,SA))+1j/np.sqrt(2)*(np.random.randn(RA,SA)))
#H=np.ones([RA,SA])
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#sender
sender_=sender(N,N_known,Ni,Nd,mpsk_map,filter_)
#print("n_start=",sender_.n_start)
#training symbols(/bits) which may be shared with receiver, when a data-aided method is used
symbols_known=sender_.symbols_known
ibits=sender_.ibits
dbits=sender_.dbits
n_start=sender_.n_start
ibits_known=sender_.ibits_known
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#with Filter(noch zu bearbeiten,überabtastung!)
receiver_=receiver(H,sender_,SNR_dB,filter_,mpsk_map)
receiver_.channel()
r_mf=receiver_.r_mf
#BER for perfect sync
yi,yd=receiver_.detector(r_mf,H)
BERi_0,BERd_0=test.BER(yi,yd,Ni,Nd,ibits,dbits)
#with offsets
off=np.exp(1j*2*np.pi*f_off*np.arange(r_mf.shape[0])*T/filter_.n_up)
r_off_ft=r_mf*np.repeat(off,RA).reshape([-1,RA])*np.exp(1j*phi_off)
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#coarse Estimation for f_off (draft)
f_off_coarse=0
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#coarse synchronisation
off_syc=np.exp(-1j*2*np.pi*f_off_coarse*np.arange(r_mf.shape[0])*T/filter_.n_up)
r_syc_coarse=r_off_ft*np.repeat(off_syc,RA).reshape([-1,RA])
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Sampling Clock Synchronization
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Joint Estimation for f_off,n_start and CSI
j=joint_estimation()
j.function(r_syc_coarse,N,N_known,T,ibits_known,symbols_known,SA,RA)
f_est=j.f_est
n_est=j.n_est
H_est=j.H_est
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Synchronisation
off_syc=np.exp(-1j*2*np.pi*f_est*(np.arange(r_mf.shape[0]))*T)
r_f_syc=r_syc_coarse*np.repeat(off_syc,RA).reshape([-1,RA])
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Detection and BER Test
yi,yd=receiver_.detector(r_f_syc,H_est)
#yi,yd=rr.detector(H_est,SNR_dB,mpsk_map,r_ft_syc)
BERi,BERd=test.BER(yi,yd,Ni,Nd,ibits,dbits)
#
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#
#if BERi<=threshold and BERd<=threshold and n_start==n_est:
if n_start==n_est:
count=1
else:
count=0
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
return count
class Link(selectable.Selectable, goocanvas.Polyline):
class Controller(selectable.Controller):
def enter(self, item, target):
self._view.hilight()
def leave(self, item, target):
self._view.unhilight()
def set_pos(self, item, target):
pass
def __init__(self, src, sink, selection):
goocanvas.Polyline.__init__(self)
selectable.Selectable.__init__(self, selection)
self.src = src
self.sink = sink
self.srcpad = src.pad
self.sinkpad = sink.pad
self.props.stroke_color = "black"
self.props.line_width = 2.0
self.props.end_arrow = True
self.checkVisibility()
self.link()
def link(self):
self.src.unblock()
self.sink.unblock()
try:
self.srcpad.link(self.sinkpad)
except gst.LinkError:
self.src.block()
self.sink.block()
def unlink(self):
pass
def select(self):
self.props.stroke_color = "red"
def deselect(self):
self.props.stroke_color = "black"
def delete(self):
if not (self.srclinked or self.sinklinked):
self._unlink()
def _unlink(self):
self.src.unlink(self)
self.sink.unlink(self)
self.src = None
self.sink = None
self.remove()
def set_pos(self, pos):
pass
def hilight(self):
self.props.line_width = 3.0
def unhilight(self):
self.props.line_width = 2.0
def updateEndpoints(self):
if self.src and self.sink:
b = self.src.socket.get_bounds()
start = (b.x1 + b.x2) / 2, (b.y1 + b.y2) / 2
b = self.sink.socket.get_bounds()
end = (b.x1 + b.x2) / 2, (b.y1 + b.y2) / 2
self.props.points = goocanvas.Points([start, end])
def checkVisibility(self):
if self.srclinked and self.sinklinked:
self.props.line_dash = goocanvas.LineDash([])
self.updateEndpoints()
else:
self.props.line_dash = goocanvas.LineDash([3.0, 3.0])
return False
srcpad = receiver()
sinkpad = receiver()
srclinked = False
sinklinked = False
@handler(srcpad, "linked")
def srcLinked(self, pad, target):
self.srclinked = True
self.checkVisibility()
@handler(srcpad, "unlinked")
def srcUnlinked(self, pad, target):
self.srclinked = False
gobject.idle_add(self.checkVisibility)
@handler(sinkpad, "linked")
def sinkLinked(self, pad, target):
self.sinklinked = True
gobject.idle_add(self.checkVisibility)
@handler(sinkpad, "unlinked")
def sinkUnlinked(self, pad, target):
self.sinklinked = False
gobject.idle_add(self.checkVisibility)
class BinView(goocanvas.Canvas):
widgets = None
selected = None
def __init__(self, pipeline, m):
goocanvas.Canvas.__init__(self)
self.props.automatic_bounds = True
self.pipeline = pipeline
self.widgets = {}
self.drag_dest_set(gtk.DEST_DEFAULT_ALL, target, gtk.gdk.ACTION_COPY)
self.connect("drag_data_received", self.__dragDataReceived)
self.selection = selectable.Selection()
self.__setupActions(m)
def __setupActions(self, m):
actiongroup = gtk.ActionGroup("binview")
actiongroup.add_actions((
("AddFile", gtk.STOCK_ADD, _("Add Filesrc"), None, None,
self.addFileAction),
("Delete", gtk.STOCK_DELETE, None, None, None,
self.deleteSelectionAction),
("Bin", None, _("_Bin")),
))
m.insert_action_group(actiongroup)
m.add_ui_from_string(ui)
def __dragDataReceived(self, w, context, x, y, selection, targetType,
time):
if targetType == TYPE_GST_ELEMENT:
elements = selection.data.split('\n')
for factory in elements:
element = gst.element_factory_make(factory)
self.addElement(element, x, y)
x += 10
y += 10
elif targetType == TYPE_TEXT_PLAIN:
incoming = [uri.strip() for uri in selection.data.split('\n')]
for uri in incoming:
if isfile(uri):
self.addFile(uri, *self.convert_from_pixels(x, y))
x += 10
y += 10
def addFileAction(self, action):
def respondCb(dialog, response):
if response == gtk.RESPONSE_OK:
x, y = 100, 100
for file in dialog.get_uris():
self.addFile(file, x, y)
x += 10
y += 10
dialog.destroy()
chooser = gtk.FileChooserDialog(_("Add Filesrc to Pipeline"), None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE,
gtk.STOCK_ADD, gtk.RESPONSE_OK))
chooser.set_default_response(gtk.RESPONSE_OK)
chooser.set_select_multiple(True)
chooser.set_modal(False)
# TODO: remember last folder and set path to that
chooser.set_current_folder(os.path.expanduser("~"))
chooser.connect('response', respondCb)
chooser.show()
def addFile(self, uri, x=100, y=100):
element = gst.element_factory_make("filesrc", os.path.basename(uri))
element.props.location = gst.uri_get_location(uri)
self.addElement(element, x, y)
def addElement(self, element, x, y):
element.set_data("pos", (x, y))
self.pipeline.add(element)
def deleteSelectionAction(self, action):
self.selection.delete()
pipeline = receiver()
@handler(pipeline, "element-added")
def element_added(self, pipeline, element):
v = ElementView(element, self.selection)
self.widgets[element] = v
x, y = element.get_data("pos")
v.set_simple_transform(x, y, 1.0, 0)
self.get_root_item().add_child(v)
@handler(pipeline, "element-removed")
def element_removed(self, pipeline, element):
if element in self.widgets:
widget = self.widgets[element]
del self.widgets[element]
widget.remove()
widget.removeFromSelection()
def main():
parser = argparse.ArgumentParser(
description = 'rqsh send and receive untility tool')
#------------Main Args------------------
parser.add_argument('-q', nargs = '+', help = 'quickly send a command and wait for result -> Unreliable')
parser.add_argument('-s', nargs = '+', help = 'send data, do not wait for response')
parser.add_argument('-l', action = 'store_true', help = 'run in listen mode, dump incoming data to cmd')
parser.add_argument('-x', action = 'store_true', help = 'run in execute mode, ')
parser.add_argument('-i', nargs='?', help="network interface, REQUIRED")
#-------------Debugging Args-----------------------
parser.add_argument('-d', help="debug mode", action='store_true')
parser.add_argument('-p', nargs = '?', type = int, help = 'define non-default port #', default = 5005)
parser.add_argument('-m', nargs = '?', type = str, help = 'define multicast group address', default = "224.3.29.71")
#TODO self test mode
#--------------File Transfer Args------------------
parser.add_argument('-g', nargs='+', help = 'get a file from a destination running -x mode',
metavar = 'address:file [local_dest]')
parser.add_argument('-t', nargs='+', help = 'transmit (send) a file to a destination running -x mode',
metavar = 'local_file address[:dest]')
#--------tuning/performance args----------
parser.add_argument('-lr', nargs = '?', type = float,
default = 0.0, help = 'expected lose rate, will calculate the N for encoder')
#--------------Main-----------------------
args = None
args = parser.parse_args(sys.argv[1:] if args is None else args)
interfaces = netifaces.interfaces()
my_ip = None
for i in interfaces:
if i == args.i:
my_ip = netifaces.ifaddresses(i).get(netifaces.AF_INET)[0]['addr']
if args.d:
print my_ip
if my_ip == None:
print 'invalid network interface'
exit(1)
sndr = sender(loss = args.lr, mc_group = args.m, port = args.p, debug = args.d, ip=my_ip)
#----------------decision tree---------------
data_header = 0
host_ip = None
host_file = None
local_file = None
#Data header types
#0 = plaintext dump/command response
#1 = command
#2 = request file
#3 = file dump/file response
if args.q: #quicksend single command
data_header = 1
recv = receiver(port = args.p, exe = False, mc_group = args.m, debug = args.d)
recv.blacklist(my_ip)
t_id = threading.Thread(target = recv.start, kwargs = {'max_messages':1})
t_id.daemon = True
t_id.start()
elif args.l: #launch daemon in listen mode
recv = receiver(port = args.p, exe = False, mc_group = args.m, debug = args.d)
recv.start(max_messages = -1)
elif args.x: #launch daemon in exe mode
recv = receiver(port = args.p, exe = True, mc_group = args.m, debug = args.d, sndr=sndr)
recv.blacklist(my_ip)
recv.start(max_messages = -1)
elif args.g: #get file
#also TODO build a file only mode
recv = receiver(port = args.p, exe = True, mc_group = args.m, debug = args.d)
recv.blacklist(my_ip)
t_id = threading.Thread(target = recv.start, kwargs = {'max_messages':1})
t_id.daemon = True
t_id.start()
data_header = 2
if len(args.g) < 1:
print 'give arguments to -g please!'
exit(1)
try:
host_ip = args.g[0].split(':')[0]
host_file = args.g[0].split(':')[1]
if len(args.g) > 1:
local_file = args.g[1]
else:
local_file = os.path.join(os.getcwd(), os.path.split(host_file)[1])
except:
print 'invalid syntax to -g'
exit(1)
elif args.t: #transmit file
data_header = 3
if len(args.t) < 1:
print 'give arguments to -t please!'
exit(1)
try:
local_file = args.t[0]
host_ip = args.t[1].split(':')[0]
if len(args.t[1].split(':')) > 1:
host_file = argt.g[1].split(':')[1]
else:
os.path.split(local_file)[1]
except:
print 'invalid syntax to -t'
exit(1)
if args.q or args.s or args.g or args.t:
#Data header types
#0 = plaintext dump/command response
#1 = command
#2 = request file
#3 = file dump/file response
#data header syntax
# 0: [header (this number)]\d[text size]\d[text]
# 1: [header]\d[command]
# 2: [header]\d[host_ip]\d[host_file]\d[local_file]
# 3: [header]\d[dest_file aka host_file]\d[payload_size]\d[payload]
#TODO find a better delimeter
delim = '#' #delimiter for rqsh syntax
#this front-end only needs to deal with 'sending' types, 1,2,3
data = str(data_header) + delim
if data_header == 2:
data += host_ip + delim + host_file + delim + local_file
elif data_header == 3:
file = open(local_file, 'r')
payload = file.read()
file.close()
data += host_file + delim + payload_size + delim + payload
elif data_header == 1:
try:
for i in args.q:
data += i + ' '
except: pass
try:
for j in args.s:
data += j + ' '
data = data[:-1]
except: pass
sndr.send(data)
if args.q or args.g:
input() #wait for all threads to finish
def sm(SNR_dB):
fc = 1 * 1e9 # LTE
offset_range = 40 * 1e-6
#print("f_max=",fc*offset_range)
#number of sender antennas
SA = 2
#number of receiver antennas
RA = 1
#data bits modulation order (BPSK)
M = 2
mpsk_map = np.array([1, -1])
#mpsk_map =1/np.sqrt(2) * np.array([1+1j, -1+1j, 1-1j, -1-1j], dtype=complex)
#mpsk_map =1/np.sqrt(2) * np.array([1, 1j, -1j, -1], dtype=complex)
#number of symbols per Frames
Ns = 2
#number of Frames
Nf = 100
#number of symbols
N = Ns * Nf
#number of training symbols
N_known = 64 * 4
N = N_known * 2
k = 8
#symbol duration
T = 1 * 1e-6
#print("f_vernachlaessigbar=",0.01/N/T)
#T=1
#Frequency offset
f_off = np.random.randint(-fc * offset_range, fc * offset_range) * 0.1
#f_off=np.random.randint(-0.01/T,0.01/T)
#N_known=int(1//T//f_off/4)
#N=10*N_known
# print("f_off=",f_off)
#symbol offset
#n_off=2
#phase offset
phi_off = np.random.random() * 2 * np.pi
phi_off = 0
#number of Index bits per symbol
Ni = int(np.log2(SA))
#number of Data bits per symbol
Nd = int(np.log2(M))
#Upsampling rate
n_up = 2
# RRC Filter (L=K * sps + 1, sps, t_symbol, rho)
K = 20
filter_ = rrcfilter(K * n_up + 1, n_up, 1, 0.5)
g = filter_.ir()
#Plot.spectrum(g,"g")
#Channel matrix
H = 1 / np.sqrt(2) * ((np.random.randn(RA, SA)) + 1j / np.sqrt(2) *
(np.random.randn(RA, SA)))
#H=np.array([[0.5,0.1]])
H = np.ones([RA, SA])
MSE_n = []
MSE_f = []
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
tries = 200
for i in range(0, tries):
#sender
sender_ = sender(N, N_known, Ni, Nd, mpsk_map, filter_, k)
# print("n_start=",sender_.n_start,sender_.n_start*n_up,(sender_.n_start+N_known)*n_up)
#training symbols(/bits) which may be shared with receiver, when a data-aided method is used
symbols_known = sender_.symbols_known
#symbols_known=ss
symbols = sender_.symbols
ibits = sender_.ibits
# dbits=sender_.dbits
ibits_known = sender_.ibits_known
index = bitarray2dec(ibits_known)
# dbits_known=sender_.dbits_known
s_BB = sender_.bbsignal()
group_delay = (g.size - 1) // 2
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#with Filter
receiver_ = receiver(H, sender_, SNR_dB, filter_, mpsk_map)
r = receiver_.r
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#with offsets
#Frequency offset before MF(+filter length)
#!!!T anpassen!!!
off = np.exp(1j * 2 * np.pi * f_off *
np.arange(sender_.bbsignal().size) * T / n_up)
r = receiver_.r * np.repeat(off, RA).reshape([-1, RA])
r_mf = receiver_.Matched_Filter(
r.real) + 1j * receiver_.Matched_Filter(r.imag)
r_mf = r_mf[2 * group_delay:-2 * group_delay]
#%%%%%%%%%%%%%%%%%
#Modified Delay Correlation
f_est, n_est, M = DC(r_mf, T, symbols_known, n_up, N_known, k)
# print("n_est=",n_est)
##
# print("f_est=",f_est)
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Frequency synchronisation
# y=r_mf*np.exp(-1j*2*np.pi*f_off*(np.arange(r_mf.shape[0])+2*group_delay)*T/n_up).reshape([-1,RA])
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
##MSE
# MSE_n.append((sender_.n_start-n_est)**2)
# MSE_f.append((f_off-f_est)**2)
MSE_n.append((sender_.n_start - n_est))
MSE_f.append((f_off - f_est) / f_off)
return np.average(MSE_n), np.average(MSE_f)
# the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # If you have a applicable agreement with GreenSocs Ltd, the terms of that # agreement prevail. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA # # ENDLICENSETEXT import gs_sa as gs from sender import sender from receiver import receiver # Describe the system sender1 = sender() receiver1 = receiver() # Start! gs.start()
class ElementView(selectable.Selectable, goocanvas.Group):
__NORMAL__ = 0x709fb899
__SELECTED__ = 0xa6cee3AA
padding = 2
def __init__(self, element, selection):
goocanvas.Group.__init__(self)
selectable.Selectable.__init__(self, selection)
self.register_instance(self)
self.element = element
self.bg = goocanvas.Rect(
parent = self,
fill_color = "grey",
radius_x = 5,
radius_y = 5)
self.text = goocanvas.Text(
parent = self,
font = "Sans 8 Bold",
text = element.get_name())
self.__sourcePads = {}
self.__sinkPads = {}
self.__links = {}
for pad in element.get_pad_template_list():
if pad.presence != gst.PAD_ALWAYS:
self.__addPad(pad)
for pad in element.pads():
self.__addPad(pad)
## public api
def joinLink(self, pad, linkObj):
self.__links[pad] = pad.direction()
def breakLink(self, pad):
del self.__links[pad]
def set_simple_transform(self, x, y, scale, rotation):
goocanvas.Group.set_simple_transform(self, x, y, scale, rotation)
for pad in self.__sourcePads.values():
pad.updateLinks()
for pad in self.__sinkPads.values():
pad.updateLinks()
## Selectable Methods methods
def select(self):
self.bg.props.stroke_color = "red"
def deselect(self):
self.bg.props.stroke_color = "black"
def delete(self):
p = self.element.get_parent()
if p:
p.remove(self.element)
element = receiver()
## element signal handlers
@handler(element, "pad-added")
def __padAdded(self, element, pad):
# this handler is called in pipeline context, and we need to add the
# pad in the UI context
print pad.get_name(), pad.get_direction(), pad
gobject.idle_add(self.__addPad, pad)
@handler(element, "pad-removed")
def __padRemoved(self, element, pad):
print pad.get_name(), pad.get_direction(), pad
# this handler is called in pipeline context, and we need to add the
# pad in the UI context
gobject.idle_add(self.__removePad, pad)
## implementation functions
def __sizepads(self, pads):
width = 0
height = 0
for pad, widget in pads.iteritems():
height += widget.height
width = max(width, widget.width)
return width, height
def __pospads(self, pads, x, y):
for widget in pads.itervalues():
widget.set_simple_transform(x, y, 1.0, 0)
y += widget.height
def __update(self):
twidth, theight = utils.get_text_dimensions(self.text)
lwidth, lheight = self.__sizepads(self.__sinkPads)
rwidth, rheight = self.__sizepads(self.__sourcePads)
width = max(twidth, lwidth + rwidth)
height = theight + max(lheight, rheight) + 5
self.bg.props.width = width
self.bg.props.height = height
self.__pospads(self.__sinkPads, 0, theight)
self.__pospads(self.__sourcePads, width - rwidth, theight)
def __addPad(self, pad):
child = make_pad_view(pad, self, self.selection)
if child.direction() == gst.PAD_SRC:
self.__sourcePads[pad] = child
else:
self.__sinkPads[pad] = child
self.add_child(child)
self.__update()
def __removePad(self, pad):
if pad.get_direction() == gst.PAD_SRC:
widget = self.__sourcePads[pad]
del self.__sourcePads[pad]
else:
widget = self.__sinkPads[pad]
del self.__sinkPads[pad]
widget.unlinkAll()
widget.remove()
self.__update()
## class methods
__instances__ = []
@classmethod
def register_instance(cls, instance):
cls.__instances__.append(weakref.proxy(instance,
cls.unregister_instance))
@classmethod
def unregister_instance(cls, proxy):
self.__instances__.remove(proxy)
@classmethod
def set_all_to_null(cls):
for instance in cls.__instances__:
instance.element.set_state(gst.STATE_NULL)
def __init__(self, ServerIP, ServerPort): self.ServerAddr = (ServerIP, ServerPort) self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.connect(self.ServerAddr) self.Receiver = receiver.receiver(self.sock) self.Sender = sender.sender(self.sock)
def __init__(self, cypher_alg):
super().__init__(cypher_alg)
self.receiver = receiver(cypher_alg)