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])