def __init__(self): Receiver.__init__(self) ResReceiver.logger.info("ResReceiver Init") try: myQueId = 0 if ResReceiver.myQueue is None: #IPC_CREAT : create or return key if it is allocated. #IPC_CREX : IPC_CREAT | IPC_EXCL #IPC_EXCL : return -1 if there is already allocated. myQueId = int(ConfManager.getInstance().getConfigData( ConfManager.MSGQUEUE_INFO, "RESTIF_S")) maxQSize = ConfManager.getInstance().getConfigData( ConfManager.MSGQUEUE_INFO, "MAX_QUEUE_SIZE") #ResReceiver.myQueue = sysv_ipc.MessageQueue(myQueId, sysv_ipc.IPC_CREAT, mode=0777, max_message_size = int(maxQSize) ) ResReceiver.myQueue = sysv_ipc.MessageQueue( myQueId, sysv_ipc.IPC_CREAT) self.resReceiver = self self.resReceiver.start() except Exception as e: ResReceiver.logger.error( "msgQueue Connection Failed.. RESTIF_S QUEUE_ID[%d] SIZE[%s] %s" % (myQueId, maxQSize, e)) return None
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 send_frame_stop_and_wait(self): # test # print(self.image) self.tableOfFrames = Image.gruop_into_frames(self.image, self.size, self.ChosenSumAlgorithm) #wyświetlenie tablicy zawierającej wszystkie ramki print(self.tableOfFrames) #zapis ilości ramek sizeoftable = len(self.tableOfFrames) #tworzy tablice o rozmiarze ilosci ramek z potwierdzeniami lub odrzuceniami pakietów for i in range(0, sizeoftable): self.ACK.append(False) #przenoszenie do receivera potrzebnych wartosci Receiver.numberOfValues = number Receiver.numberOfFrames = sizeoftable Receiver.reset_Data(Receiver) i = 0 endOfWindow = self.windowSize - 1 print("Rozmiar tablicy ramek:") print(sizeoftable) #wysyłanie poszczególnych ramek while i < sizeoftable: self.ACK[i] = self.receiver.receive_frame_stop_and_wait( self.tableOfFrames[i], i) if self.ACK[i]: i += 1 else: self.ACK[i] = False continue
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')
class TrafficManager(threading.Thread): def __init__(self, iface='eth1', filter="dst='192.168.137.0'", rx_port=50000, tx_port = 50001): super().__init__() self.log = logging.getLogger(self.__class__.__name__) self.iface = iface self.filter = filter self.rx_port = rx_port self.tx_port = tx_port self._stopRun = False self._is_running = False self.transmitter = None self.receiver = None def start(self): self._is_running = True self.create_receiver() self.create_transmiter() def stop(self): _stopRun = True if self.transmitter is not None: self.transmitter.stop() self.transmitter = None if self.receiver is not None: self.receiver.stop() self.receiver = None self._is_running = False def create_receiver(self): self.receiver = Receiver(self.iface, self.filter, self.rx_port) self.receiver.start() def create_transmiter(self): self.transmitter = Transmitter(self.iface, self.filter, self.tx_port) self.transmitter.start()
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 __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 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 __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 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 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 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()
class UserInterface(threading.Thread): def __init__(self, Debug=False): self.debug = Debug threading.Thread.__init__(self) self.setName("GUI") self.fenetre = Tk() self.fenetre.title("Commande") self.senderbox = Frame(self.fenetre) self.senderbox.pack(side="left", expand=False, padx=5, pady=5) self.sender = Sender(self, self.senderbox, Debug=self.debug) self.receiverbox = Frame(self.fenetre) self.receiverbox.pack(side="right", expand=True, fill="x", padx=5, pady=5) self.receiver = Receiver(self.receiverbox, Debug=self.debug) self.start() def run(self): if self.debug is True: print("[GUI] : GUI >> Interface Graphique operationnel") self.fenetre.mainloop() def quitter(self): self.fenetre.quit() def setConnexion(self, conn): self.sender.setConnexion(conn) def log(self, provenance, message): provenance = provenance+"/GUI" try: self.receiver.log(provenance, message) except: if self.debug is True: print("[GUI] : GUI >> Attention connexion avec le logger non existant !") print("message: " + message)
def send_frame_selective(self): #stworzenie tablicy z ramkami self.tableOfFrames = Image.gruop_into_frames(self.image, self.size, self.ChosenSumAlgorithm) # zapisuje ilosc ramek dopedli wysylania sizeoftable = len(self.tableOfFrames) # tworzy tablice o rozmiarze ilosci ramek z potwierdzeniami lub odrzuceniami pakietów for i in range(0, sizeoftable): self.ACK.append(False) # przenoszenie do receivera potrzebnych wartosci Receiver.numberOfFrames = sizeoftable Receiver.reset_Data(Receiver) endOfWindow = self.windowSize - 1 i = 0 # petla wysylajaca ramki zgodnie z regulami algotrytmu selektywnego while i < sizeoftable: isCorrectFrame = True # petla operujaca oknem i wysylajaca te ramki ktore sender od nas chce for j in range(i, endOfWindow + 1): if j == sizeoftable: break if self.ACK[j] == False: # time.sleep(0.2) print(f'SENDER: wysłano obiekt nr "{j}"') self.ACK[j] = self.receiver.recieve_frame( self.tableOfFrames[j], j) else: pass # petla sprawdzajaca czy cala ramka zostala przeslana bez zarzutów for j in range(i, endOfWindow + 1): if j == sizeoftable: break if self.ACK[j] == False: isCorrectFrame = False # warunki odpowiadajace za przesuwanie sie okna gdy ramka jest dobra lub gdy ktorys z pakietow jest uszkodzony if isCorrectFrame: if (endOfWindow + self.windowSize) >= sizeoftable: endOfWindow = sizeoftable else: endOfWindow += self.windowSize i += self.windowSize else: count = 0 for j in range(i, endOfWindow + 1): if self.ACK[j] == True: count += 1 else: break endOfWindow += count i += count
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 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 get_receiver_req(self): rcvrs = [ [r.abbreviation for r in rg.receivers.all().order_by("id")] for rg in self.receiver_group_set.all().order_by("id") ] rc = ReceiverCompile(Receiver.get_abbreviations()) return rc.denormalize(rcvrs)
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 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 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, 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 __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 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 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 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 onRecAppendEntriesRPC(self,message): #print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive AppendEntriesRPC from: '+\ #str(message.leaderId)+" term"+str(message.term)) if(StateController.eql(State.state,'follower')): reply=Follower.onRecAppendEntriesRPC(message) else: reply=Receiver.onRecAppendEntriesRPC(message) sender=Sender('AppendEntriesRPCReply',reply) sender.send(self.dc_list[message.leaderId])
def onRecAppendEntriesRPC(self, message): #print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive AppendEntriesRPC from: '+\ #str(message.leaderId)+" term"+str(message.term)) if (StateController.eql(State.state, 'follower')): reply = Follower.onRecAppendEntriesRPC(message) else: reply = Receiver.onRecAppendEntriesRPC(message) sender = Sender('AppendEntriesRPCReply', reply) sender.send(self.dc_list[message.leaderId])
def SR_Receiver(sock, debug, parent): #create filepath to parent's (Server/Client) receiving temp file fileName = 'temp.txt' fileTemp = os.path.join(os.getcwd(), parent, "Data", "Receiver") file = os.path.join(os.getcwd(), fileTemp, fileName) buffer = "" #initialize receiver object receiver = Receiver(sock, debug, parent) try: #receive payload from selective repeat senderAddress = receiver.receive(fileName) #read payload from temp file with open(file, "r") as f: buffer += f.read() #delete temp file os.remove(file) return buffer, senderAddress except Exception as e: print("Exception Occured: " + str(e))
def onRecReqVoteRPC(self, message): #print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive ReqVoteRPC from: '+\ #str(message.candidateId)+" term"+str(message.term)) if (StateController.eql(State.state, 'follower')): reply = Follower.onRecReqVoteRPC(message) else: reply = Receiver.onRecReqVoteRPC(message) #print(reply.voteGranted) sender = Sender('RequestVoteRPCReply', reply) sender.send(self.dc_list[message.candidateId])
def onRecReqVoteRPC(self,message): #print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive ReqVoteRPC from: '+\ #str(message.candidateId)+" term"+str(message.term)) if(StateController.eql(State.state,'follower')): reply=Follower.onRecReqVoteRPC(message) else: reply=Receiver.onRecReqVoteRPC(message) #print(reply.voteGranted) sender=Sender('RequestVoteRPCReply',reply) sender.send(self.dc_list[message.candidateId])
def __init__(self, Debug=False): self.debug = Debug threading.Thread.__init__(self) self.setName("GUI") self.fenetre = Tk() self.fenetre.title("Commande") self.senderbox = Frame(self.fenetre) self.senderbox.pack(side="left", expand=False, padx=5, pady=5) self.sender = Sender(self, self.senderbox, Debug=self.debug) self.receiverbox = Frame(self.fenetre) self.receiverbox.pack(side="right", expand=True, fill="x", padx=5, pady=5) self.receiver = Receiver(self.receiverbox, Debug=self.debug) self.start()
for i in range(0,5001, 10): if i < 200: stepFunc.append( Sample(i, 0, 0, 0) ) else: stepFunc.append( Sample(i, 1, 1, 1) ) predictor = DRPredictor() predictedData = predictor.getPredictedData(stepFunc, predictionInterval, samplingInterval) s.exportData(logDir + "PredictionData.txt", predictedData) transmitter = DRTransmitter(heartbeat) drTxPackets = transmitter.getTransmittedPackets(.9, predictedData) s.exportData(logDir + "TransmittedData.txt", drTxPackets) network = Network() drRxPackets = network.getReceivedPackets(drTxPackets, delay, jitter, packetLoss) s.exportData(logDir + "ReceivedData.txt", drRxPackets) receiver = Receiver() drRxFilteredPackets = receiver.getFilteredData(drRxPackets) s.exportData(logDir + "FilteredData.txt", drRxFilteredPackets) convergedData = s.convergeData(drRxFilteredPackets, logDir, "-", samplingInterval, interpolationType, reconstructionThreshold)[0] iData = [ [] ] * 4 cData = [ [] ] * 4 iData[0], iData[1], iData[2], iData[3] = s.splitData(stepFunc) cData[0], cData[1], cData[2], cData[3] = s.splitData(convergedData) pylab.figure(1) pylab.plot(iData[0], iData[1], 'k-', cData[0], cData[1], 'b-') pylab.axis([ 0, 2000, -.1, 1.8 ])
predictor = DRPredictor() predictedData = predictor.getPredictedData(inputData, predictionInterval, samplingInterval) # Run the transmission algorithm print "Simulating the transmission algorithm..." transmitter = DRTransmitter(heartbeat) DRTxPackets = transmitter.getTransmittedPackets(threshold, predictedData) # Simulate the transmission of the packets print "Simulating the network..." network = Network() DRRxPackets = network.getReceivedPackets(DRTxPackets, delay, jitter, packetLoss) # Receive the packets print "Receiving the packets..." receiver = Receiver() DRRxData = receiver.getFilteredData(DRRxPackets) # Reconstruct the transmitted and received data print "Reconstructing the signals..." reconstructor = SnapReconstructor() DRTxData = reconstructor.getReconstructedSignal(DRTxPackets, samplingInterval) DRRxReconData = reconstructor.getReconstructedSignal(DRRxData, samplingInterval) # Split data into components inputTime = range(0, len(inputData) * samplingInterval, samplingInterval) x = [] y = [] z = [] transmittedTime = [] txX = []
print("**************************************************************************") print("*** Bare Quad X - Monitoring Tool ***") print("*** ***") print("*** Purpose ***") print("*** - Determine the min, max, neutral values ***") print("*** - Display the current value and compare it to the neutral value ***") print("**************************************************************************") print(">>> Center all sticks...") print(">>> During calibration, move sticks in all positions") print(">>> Press on [Ctrl]+[C] when finished") print("") input("[ ...Press any key when ready... ]") # Instantiate the receiver object receiver = Receiver(port=RX_PORT, speed=RX_SPEED, debug=False) # Main loop: record all values and adapt the ranges per channel try: while True: if receiver.read_serial(): for i in range(0, 4): if receiver.channels[i] > 0: # Save the received value and adapt the boundaries if necessary input_value[i] = receiver.channels[i] input_min[i] = min(input_min[i], input_value[i]) input_max[i] = max(input_max[i], input_value[i]) # Save the first value for each channel as the neutral position if output_neutral[i] == 0: output_neutral[i] = input_value[i]
def receive(): if( args.deviceName ): print "Receiver info:" print "\tDevice:\t\t\t\t%s" %( args.deviceName ) print "\tDuration:\t\t\t%d" %( args.duration ) print "\tNumber of training symbols:\t%d" %( args.numberOfTrainingSymbols ) print "\nFormat info:" print "\tBit depth:\t\t\t%d" %( args.bitDepth ) print "\tNumber of channels:\t\t%d" %( args.numberOfChannels ) print "\tSample rate:\t\t\t%.02f" %( args.sampleRate ) print "\nModulation info:" print "\tBits per symbol:\t\t%d" %( args.bitsPerSymbol ) print "\tSamples per symbol:\t\t%d" %( args.samplesPerSymbol ) print "\tCarrier frequency:\t\t%.02f" %( args.carrierFrequency ) print "\tSample rate:\t\t\t%.02f" %( args.sampleRate ) print "\tOutput signal:\t\t\t%s" %( "Yes" if( args.writeOutput ) else "No" ) print "\nWideband filter info:" print "\tFirst stopband:\t\t\t%.02f" %( args.widebandFirstStopband ) print "\tFirst passband:\t\t\t%.02f" %( args.widebandFirstPassband ) print "\tSecond passband:\t\t%.02f" %( args.widebandSecondPassband ) print "\tSecond stopband:\t\t%.02f" %( args.widebandSecondStopband ) print "\nNarrowband filter info:" print "\tFirst stopband:\t\t\t%.02f" %( args.narrowbandFirstStopband ) print "\tFirst passband:\t\t\t%.02f" %( args.narrowbandFirstPassband ) print "\tSecond passband:\t\t%.02f" %( args.narrowbandSecondPassband ) print "\tSecond stopband:\t\t%.02f" %( args.narrowbandSecondStopband ) print "\nFilter info:" print "\tPassband attenuation:\t\t%.02f" %( args.passbandAttenuation ) print "\tStopband attenuation:\t\t%.02f" %( args.stopbandAttenuation ) print "\nSpread spectrum info:" print "\tSamples per chip:\t\t%d" %( args.samplesPerChip ) print "\tPolynomial degree:\t\t%d" %( args.polynomialDegree ) print "\tFirst generator:\t\t0x%x" %( args.firstGenerator ) print "\tSecond generator:\t\t0x%x" %( args.secondGenerator ) print "\tFirst initial value:\t\t0x%x" %( args.firstInitialValue ) print "\tSecond initial value:\t\t0x%x" %( args.secondInitialValue ) if( args.writeOutput ): print "\nOutput info:" print "\tFile name:\t\t\t%s" %( args.outputFileName ) device = findDevice( args.deviceName ) receiver = \ Receiver ( args.bitDepth, args.numberOfChannels, args.sampleRate, args.bitsPerSymbol, args.samplesPerSymbol, args.carrierFrequency, args.widebandFirstStopband, args.widebandFirstPassband, args.widebandSecondPassband, args.widebandSecondStopband, args.narrowbandFirstStopband, args.narrowbandFirstPassband, args.narrowbandSecondPassband, args.narrowbandSecondStopband, args.passbandAttenuation, args.stopbandAttenuation, args.polynomialDegree, args.firstGenerator, args.secondGenerator, args.firstInitialValue, args.secondInitialValue, args.samplesPerChip, args.numberOfTrainingSymbols, args.outputFileName, args.writeOutput, args.duration ) if( device and receiver ): if( device.doesSupportRecording() ): receiver.record( device ) print "Done receiving." else: print "ERROR: Device '%s' does not support recording." \ %( args.deviceName ) else: print "ERROR: Could not find device %s." %( args.deviceName ) else: print "ERROR: Device name must be set for energy detecting."