def order(self, name, cmd):
cmd = cmd.strip().upper()
#tell the invoker(broker) to execute a command based on a new receiver(stock)
if (cmd == "BUY"):
self.invoker.execute(BuyCommand(Receiver(name)))
elif (cmd == "SELL"):
self.invoker.execute(SellCommand(Receiver(name)))
else:
raise ValueError("Invalid command in Client.order")
def start_transmission(self):
if self.client_mode == MainWindow.RECEIVER_MODE:
foldername = self.path_line_edit.text()
if foldername == '':
foldername = '.'
self.worker = Receiver(foldername, self.SIGNALS)
if self.client_mode == MainWindow.SENDER_MODE:
filename = self.path_line_edit.text()
parameters = self.parameters()
self.worker = Sender(filename, parameters, self.SIGNALS)
self.log_signal.connect(self.log)
self.on_finish_signal.connect(self.on_finish)
dispatcher.connect(self.trigger_log_signal,
self.LOG_SIGNAL,
weak=False)
dispatcher.connect(self.trigger_on_finish_signal,
self.FINISH_SIGNAL,
weak=False)
self.worker.start()
self.stacked_widget.setCurrentIndex(MainWindow.LOG_PAGE)
def start_test(chosen_algorithm, control_method, probability, windows_size,
packet_size, model, P01, P10):
img = Image.open("test.jpg")
receiver = Receiver()
sender = Sender(receiver, control_method, windows_size, packet_size)
sender.set_ts_interference(probability, model, P01, P10)
img_array = np.asarray(img)
sender.data_to_binary(img_array)
sender.split_array()
sender.send_frames(chosen_algorithm)
error_counter = 0
ber = 0
for j in range(0, len(receiver.result)):
final_pack = receiver.result[j].astype(np.uint8)
start_pack = sender.packets[j]
for i in range(0, packet_size):
if start_pack[i] != final_pack[i]:
error_counter += 1
j += 1
ber = error_counter / (len(receiver.result) * packet_size) * 100
final_img = receiver.finalize_img()
return receiver.numberOfAcceptedPackets, receiver.numberOfRejectedPackets, ber
def testReceiverSetReceive(self, mock_pika, mock_callback):
r = Receiver()
r.callback = "some method"
r.setReceive("queueRec")
mock_pika.BlockingConnection.return_value.channel.return_value.basic_consume.assert_called_with(
'some method', queue='queueRec')
def main():
#Start with the case of the Rx and Tx on the same floor
"""
[power,time_mat,power_mat]=calc_power_at_position(100,100)
print("Total_receied power is: ", power)
imp_resp = calc_impulse_response(time_mat, power_mat, 80)
plt.plot(imp_resp)
plt.show()"""
count_x = 0
count_y = 0
power_xy = np.zeros((10, 20))
x = 400
Rec = Receiver(10, 20, 10)
Rec.set_type("IM")
print(Rec)
Rec.change_height(140)
print(Rec)
Geo = Room_Geometry(300, 300, 300)
Geo.set_points([10, 10, 10], [100, 200, 300])
print(Geo)
#for y in range(0,900,100):
#print(get_elevation([x,y,300],[200,40,100]))
#[Angle, Elevation]=get_elevation_and_azimuth_angles([x,y,300],[200,0,100])
"""
for i in range(10):
for j in range(20):
print(i,j)
[power, Time, powers] = calc_power_at_position(i*40,j*40)
power_xy[i,j] = power
plt.imshow(power_xy, cmap='hot', interpolation='nearest')
plt.show()
"""
print("main function called ")
def __init__(self, client):
QMainWindow.__init__(self)
# setup ui
self.setAttribute(Qt.WA_TranslucentBackground)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.bt_send.clicked.connect(self.bt_send_message)
self.ui.textEdit_message.installEventFilter(self)
self.ui.textEdit_message.setFocus()
# declare elements necessary for message list object
self.client = client
self.brush = QBrush()
self.model = QtGui.QStandardItemModel()
# setup connection info
self.HOST = '127.0.0.1'
self.PORT = 60453
self.ENCODE_FORMAT = "utf-8"
self.nick = 'nick'
# create object of Receiver class, connect to messageSignal and run it in separate thread
self.receiver = Receiver(self.client)
self.receiver.messageSignal.connect(self.new_message)
self.thread1 = threading.Thread(target=self.receiver.run)
self.thread1.start()
def main():
# sleep so rabbit can get all set up,
# and we don't get mad throwing errors all around the place
time.sleep(15)
initialize_log()
receiver = Receiver()
receiver.run()
def __init__(self):
self.frequency = 0
self.posX = 0
self.posY = 0
self.posZ = 0
self.chooseEncryption = "Hamming"
self.receiver = Receiver()
self.noiseLevel = 0.05
def setUp(self):
""" Setup function TestTypes for class Receiver """
self.ReceiverObj = Receiver(receiver_config, rx_data, bypass)
self.receiver_config = self.ReceiverObj.receiver_config
self.rx_data_in = self.ReceiverObj.rx_data_in
self.bypass = self.ReceiverObj.bypass
pass
def main():
"""
The client code can parameterize an invoker with any commands.
"""
invoker = Invoker()
invoker.set_on_start(SimpleCommand("Di Holi!"))
receiver = Receiver()
invoker.set_on_finish(ComplexCommand(receiver, "Enviar un email", "Guardar un reporte"))
invoker.do_something_important()
def __init__(self) -> None:
super().__init__()
self.reciver: Receiver = Receiver()
self.sfcs: set = set()
self.ovs: OpenvSwitch = OpenvSwitch()
self.lock = threading.Lock()
t1 = threading.Thread(target=self.checkMsg)
t2 = threading.Thread(target=self.reciver.receive, args=(self.lock, ))
t1.start()
t2.start()
def __init__(self, numOfInputs):
self.transmitter = Transmitter()
self.receiver = Receiver()
self.wirelessChannel = WirelessChannel(0.1)
self.numOfInputs = numOfInputs
self.sigmaValues = [10, 1, 0.1]
self.reveivedPoints = []
self.colors = ['purple', 'yellow', 'orange']
self.hammingProbs = []
self.qpskProbs = []
def listen(ctx, verbose, home_id):
"""
Passive monitoring of network
:param ctx: shared context
:param verbose: show received frames
:param home_id: filter frames including specified home-id
"""
# initialize
signal.signal(signal.SIGINT, signal_handler)
cfg = ctx.obj[CONFIGURATION]
cfg.home_id = home_id
cfg.verbose = verbose
honeylog = ctx.obj[LOGGER]
with multiprocessing.Manager() as manager:
# initialize shared network and decoy information
network = manager.dict(load_json(cfg.networks_path + '/' + cfg.network_file))
decoys = manager.dict(load_json(cfg.networks_path + '/' + cfg.decoys_file))
# init stats
inner_stats = init_stats_dict()
stats_real = manager.dict(inner_stats.copy())
stats_malicious = manager.dict(inner_stats.copy())
stats_invalid = manager.dict(inner_stats.copy())
stats_in = manager.dict(inner_stats.copy())
stats_out = manager.dict(inner_stats.copy())
stats = {STAT_REAL: stats_real,
STAT_MALICIOUS: stats_malicious,
STAT_INVALID: stats_invalid,
STAT_IN: stats_in,
STAT_OUT: stats_out}
frames_in = list()
frames_out = list()
# initialize components
receiver = Receiver(cfg, network, decoys, honeylog, frames_in, frames_out)
monitor = Monitor(cfg, network, decoys, honeylog, stats)
receiver.monitor = monitor
monitor.receiver = receiver
# start configuration
configuration_process = Process(target=set_configuration, args=(cfg, honeylog))
configuration_process.start()
# if not verbose
if not verbose:
# show only stats
statsview_process = Process(target=stats_view, args=(stats, ctx.obj[DEBUG_LEVEL]))
statsview_process.start()
# start reception
receiver.start(False, True)
def set_threads(self, manager):
self.ts = Sender(self.client.multicast_addr, self.client.port,
self.client.pvt_port)
self.ts.start()
self.tr = Receiver(self.client.multicast_addr, self.client.port,
manager)
self.tr.start()
self.trp = Receiver_pvt(manager)
self.trp.start()
self.tl = Listener(manager)
self.tl.start()
def add(ctx, home_id):
"""Add single new device to a network information"""
configuration = ctx.obj[CONFIGURATION]
configuration.home_id = home_id
logger = ctx.obj[LOGGER]
network = load_json(configuration.networks_path + '/' +
configuration.real_networks_name)
decoys = load_json(configuration.networks_path + '/' +
configuration.virtual_networks_name)
receiver = Receiver(configuration, network, decoys, logger, None, None)
receiver.add_device(home_id)
def record(ctx):
"""Records frames until users interrupt"""
configuration = ctx.obj[CONFIGURATION]
logger = ctx.obj[LOGGER]
network = load_json(configuration.networks_path + '/' +
configuration.real_networks_name)
decoys = load_json(configuration.networks_path + '/' +
configuration.virtual_networks_name)
receiver = Receiver(configuration, network, decoys, logger, None, None)
monitor = Monitor(configuration, network, decoys, logger, None, receiver)
receiver.monitor = monitor
monitor.record()
def transmitData(inputFile, logDir, predictionInterval, samplingInterval,
heartbeat, drThreshold, delay, jitter, packetLoss):
# Import data
print "Importing data..."
importer = Importer()
rawInputData = importer.getInputData(inputFile, samplingInterval)
exportData(logDir + "RawInputData.txt", rawInputData)
# Filtering input data
print "Filtering data..."
samplingFreq = int(1e3 / samplingInterval)
taps = 80
bands = [0.0, 10, 11, 50.0]
weights = [1, 0]
coefficients = scipy.signal.remez(taps, bands, weights, Hz=samplingFreq)
gain = 1.0 / sum(coefficients)
filteredInputData = filterData(rawInputData, logDir, "cc",
samplingInterval, coefficients)[0]
filteredInputData = amplifyData(filteredInputData, gain)
exportData(logDir + "FilteredInputData.txt", filteredInputData)
# Create the prediction vectors
print "Creating the prediction vectors..."
predictor = DRPredictor()
predictedData = predictor.getPredictedData(filteredInputData,
predictionInterval,
samplingInterval)
exportData(logDir + "PredictionData.txt", predictedData)
# Run the transmission algorithm
print "Simulating the transmission algorithm..."
transmitter = DRTransmitter(heartbeat)
drTxPackets = transmitter.getTransmittedPackets(drThreshold, predictedData)
exportData(logDir + "DRTxPackets.txt", drTxPackets)
# Simulate the transmission of the packets
print "Simulating the network..."
network = Network()
drRxPackets = network.getReceivedPackets(drTxPackets, delay, jitter,
packetLoss)
exportData(logDir + "DRRxPackets.txt", drRxPackets)
# Receive the packets
print "Receiving the packets..."
receiver = Receiver()
drRxFilteredPackets = receiver.getFilteredData(drRxPackets)
exportData(logDir + "DRRxData.txt", drRxFilteredPackets)
return [
rawInputData, filteredInputData, predictedData, drTxPackets,
drRxPackets, drRxFilteredPackets
]
def __init__(self, buff_size, serve_per_timestep, ttl, sender_num,
long_time, path):
self.log = open(path, "w")
self.dest = Receiver(self, buff_size, serve_per_timestep)
self.senders = [
Sender(self, self.dest, long_time, ttl, i, ttl / sender_num)
for i in range(sender_num)
]
# self.senders += [CompetitiveSender(self, self.dest, long_time, ttl, i + sender_num, ttl/sender_num)
# for i in range(sender_num)]
self.messages = deque()
self.ttl = ttl
self.time = 0
def main(self):
command_helper = InputHelper(
["caesar", "multiplicative", "affine", "unbreakable", "rsa", "exit"]
)
try:
next_command = command_helper.get_legal_input("Please enter a command: \n")
sender = Sender()
receiver = Receiver()
hacker = Hacker()
cipher_algorithm = None
if next_command == "caesar":
cipher_algorithm = Caesar()
if next_command == "multiplicative":
cipher_algorithm = Multiplicative()
if next_command == "affine":
cipher_algorithm = Affine()
if next_command == "unbreakable":
cipher_algorithm = Unbreakable()
if next_command == "rsa":
cipher_algorithm = RSA()
hacker = None
if next_command == "exit":
sys.exit(0)
sender.set_cipher_algorithm(cipher_algorithm)
receiver.set_cipher_algorithm(cipher_algorithm)
keys = cipher_algorithm.generate_keys()
self.__logger.info(f"Keyset: {keys}")
sender.set_key(keys["encryption"])
receiver.set_key(keys["decryption"])
message = input("Please input a message to be encrypt:\n")
encrypted_text = sender.operate_cipher(message)
if hacker is not None:
hacker.set_cipher_algorithm(cipher_algorithm)
self.__logger.info(
f"Hackerman found: {hacker.hack(encrypted_text, next_command)}"
)
decrypted_text = receiver.operate_cipher(encrypted_text)
self.__logger.info(
f"{message} => {encrypted_text} => {decrypted_text} (Success={cipher_algorithm.verify(sender.get_key(), receiver.get_key(),message)})"
)
except KeyboardInterrupt:
return self.main()
def record(ctx):
"""
Maps real network, record its communication, anonymize it.
Records are saved into pcap files. Network and decoy information are saved into json files.
:param ctx: shared context
"""
cfg = ctx.obj[CONFIGURATION]
honeylog = ctx.obj[LOGGER]
network = load_json(cfg.networks_path + '/' + cfg.network_file)
decoys = load_json(cfg.networks_path + '/' + cfg.decoys_file)
receiver = Receiver(cfg, network, decoys, honeylog, None, None)
receiver.start(recording=True)
def main():
# ------------------------------------------------------------------------ #
# 0. Subscribe to the broker
# ------------------------------------------------------------------------ #
receiver = Receiver()
# Connect to the data hub
receiver.connect(host=DATA_HUB_IP, uname=DATA_HUB_UNAME, pwd=DATA_HUB_PWD)
# Connect to the exchange
receiver.get_data_from_exchange(ex_name=EX_NAME,
topic=SUB_TOPIC,
callback=process_data)
def main():
# ------------------------------------------------------------------------ #
# 0. Subscribe to the broker
# ------------------------------------------------------------------------ #
receiver = Receiver()
# Connect to the data hub
uname = "admin"
password = "******"
receiver.connect(host=DATA_HUB_IP, uname=uname, pwd=password)
# Connect to the exchange
receiver.get_data_from_exchange(ex_name=EX_NAME,
topic=SUB_TOPIC,
callback=process_data)
def simulate(self):
self.sender = Sender(self.source_size, self.distribution)
self.receiver = Receiver(self.source_size, self.error_rate, fast_mode=self.fast_mode)
successful_decode = False
successful_send = False
while not self.receiver.decoded:
# Send a packet and attempt to decode if it is received
if not successful_decode:
successful_send = self.send_packet()
if successful_send:
successful_decode = self.decode(pckt1_sent=self.packet_len_1_sent)
self.packet_len_1_sent = False
# print(self.receiver.result_message)
# print(self.receiver.total_received)
return self.receiver.total_received
def __init__(self, parent):
super().__init__()
# Init signal params
# TODO - Change to correct params for PPM signal
self.rate = 1000
self.format = 2
self.channels = 1
# Init default variables
self.receiver = Receiver(self)
self.signalData = [
] # DataSamples of the PPM signal (simple array of ints with max and minimum at +/-(2^15-1)
# Assign parent app
self.parent = parent
self.init_ui()
def getDCRContinuumParams(config, ifSys):
"Set obvious manager parameters for these types of observations"
ifPaths = ifSys.ifPaths
# simple enough!
motorRack = ('MotorRack,receiver', config['receiver'])
dcr = getDCRParams(config, ifPaths)
scSubsystem = getScanCoordinatorDCRContinuumSysParams(config)
# TBF: are these correct?
tuningFreq = ifSys.tuningFreq #config['restfreq']
centerFreq = str(config['center_freq'])
velocity = ifSys.velocity # 0.
vdef = ifSys.vdef #config['vdef']
rxMgr = Receiver(
config, ifSys
) #tuning_freq=tuningFreq, bw_total=ifSys.bwTotal, if_center=tuningFreq)
rxMgr.setParams()
# s12 = 4
s12 = None
lo1 = LO1(config, tuningFreq, centerFreq, velocity, vdef, s12_value=s12)
ifRack = IFRack(config, ifSys, rxMgr)
# TBF: why is this singled out to be called last in config tool?
ifRack.set_laser_power()
# TBF: what else?
# put them together
params = [
motorRack,
]
params.extend(dcr)
params.extend(scSubsystem)
params.extend(rxMgr.getParams())
params.extend(lo1.getParams())
params.extend(ifRack.getParams())
return params
def add_peer(self, remote_address, port):
if not (remote_address == '' and port == ''):
s = socket.socket()
s.connect((remote_address, int(port)))
s.send(('*PRT*:' + str(self.port)).encode())
callbacks = {
'update_address_list': self.update_address_list,
'add_address': self.add_address,
'send_address': self.send_address,
'add_peer': self.add_peer,
'remove_socket': self.remove_socket
}
full_address = remote_address + ':' + str(port)
self.addresses[full_address] = {
'receiver': Receiver(s, remote_address, callbacks),
'socket': s,
'port': None
}
self.addresses[full_address]['receiver'].start()
def verify_hacker():
for name, cipher in cipher_list.items():
key_encrypt, key_decrypt = cipher.generate_keys()
sender = Sender(cipher=cipher, key=key_encrypt)
receiver = Receiver(cipher=cipher, key=key_decrypt)
hacker = Hacker(cipher=cipher)
clear_text = "Hello World"
encrypted_message = sender.send_message(clear_text)
decrypted_message = receiver.receive_message(encrypted_message)
decrypted_hacker = hacker.receive_message(encrypted_message)
print(" ")
print(f"Current cipher: {name}")
print("Clear text: ", clear_text)
print("Hacked: ", decrypted_hacker)
def main(argv):
# Should initialize a Receiver with window size
receiver = Receiver(int(argv[3]), float(argv[4]))
# Should bind to address
# Should listen to 10
receiver.udp.bind(('', int(argv[2])))
# Enter a while true loop
while (True):
# print('Waiting')
# Keep on waiting for requests with function accept and get transmitter address
client = receiver.handle_message()
# Check tranmitter address in list
# If it is already in the list, check if frame is in sliding window range:
# If it is insert in the siding window and send ack
# Else just ignore
# Else create new client and perform exactly the same tasks
# Iterate over client window writing all messages in order in the file until first empty position. Slide window accordingly
# print('Printing now...')
# client.print_window()
position = 0
receiver.lock.acquire()
iterator = client.window.buffer[position]
while (iterator.message != None):
with open(argv[1], "a") as output:
# client.print_window()
# print()
output.write(iterator.message + '\n')
# Should slide window
position += 1
try:
iterator = client.window.buffer[position]
except:
break
client.window.slide_window(position)
receiver.lock.release()
def start_up(self, ser, ros_is_on, traj, step_is_on):
self.last_print_time = time.time()
if (not self.first):
self.ser = ser
self.tx.change_port(ser)
self.rx.change_port(ser)
return
self.first = False
self.ros_is_on = ros_is_on
self.step_is_on = step_is_on
self.use_trajectory = False
self.tx = Transmitter(ser)
self.rx = Receiver(ser, ros_is_on)
if (self.ros_is_on == True):
rospy.init_node('soccer_hardware', anonymous=True)
rospy.Subscriber("robotGoal",
RobotGoal,
self.trajectory_callback,
queue_size=1)
self.rx.pub = rospy.Publisher('soccerbot/imu', Imu, queue_size=1)
self.rx.pub2 = rospy.Publisher('soccerbot/robotState',
RobotState,
queue_size=1)
else:
trajectories_dir = os.path.join("trajectories", traj)
try:
self.trajectory = np.loadtxt(open(trajectories_dir, "rb"),
delimiter=",",
skiprows=0)
logString("Opened trajectory {0}".format(traj))
self.use_trajectory = True
except IOError as err:
logString("Error: Could not open trajectory: {0}".format(err))
logString(
"(Is your shell running in the soccer-communication directory?)"
)
logString("Standing pose will be sent instead...")
def config():
# Dimension given in cm
global xDimension
global yDimension
if TESTING == True:
xDimension = 1000
yDimension = 1000
receiver1 = Receiver(0, Position(0, 0), 0)
receiver2 = Receiver(1, Position(0, yDimension), 0)
receiver3 = Receiver(2, Position(xDimension, yDimension), 0)
receiver4 = Receiver(3, Position(xDimension, 0), 0)
else:
xDimension = 518
yDimension = 335
receiver1 = Receiver(0, Position(0, yDimension), math.radians(-62))
receiver2 = Receiver(1, Position(0, 0), 0)
receiver3 = Receiver(2, Position(xDimension, yDimension),
math.radians(100))
receiver4 = Receiver(3, Position(xDimension, 0), 0)
global receivers
receivers = np.array([receiver1, receiver2, receiver3, receiver4])
