def __init__(self, server_ip, port, parent=None): QThread.__init__(self, parent=parent) self.server_ip = server_ip self.port = port self.parent = parent self.service = receiver.Receiver(server_ip, port, parent) self.geo = None
def startReceiver(self): """Initiate the receiver""" self.isRunning = True self.receiverPort = self.PORTENTRY.get() self.receiverPort = int(self.receiverPort) if self.receiverPort < 1024 or self.receiverPort > 65535: tkMessageBox.showerror( "Invalid PORT", self.receiverPort + " is an invalid port. Please enter a valid Port.") return False self.receiverThread = receiver.Receiver(self.receiverPort, self.frameQueue) self.receiverThread.start() while self.isRunning: if not self.frameQueue.empty(): message = self.frameQueue.get() im = Image.fromstring('RGB', (640, 480), message) im = ImageTk.PhotoImage(image=im) self.PICTFRAME["image"] = im self.PICTFRAME._image_cache = im else: continue self.update() self.frameQueue.queue.clear() self.receiverThread.isRunning = False return True
def __init__(self, serverAddr): self.remoteAddr = serverAddr self.SequenceNumber = helpers.getISN() self.lastack = None try: self.sockd = socket(AF_INET,SOCK_DGRAM) except: raise self.sockd.connect(serverAddr) self.address = self.sockd.getsockname() self.sender = sender.Sender(self.sockd) self.receiver = receiver.Receiver(self) # send SYN to server print("Initial sequence number: " + str(self.SequenceNumber)) h = packet.Header(self.address[1], self.remoteAddr[1], self.SequenceNumber, 0, synf=1, ackf=0) self.sockd.send(h.pack()) self.SYNSent()
def __init__(self, ask_samp_rate=4E6, num_demod=4, hw_args="uhd", record=True, lockout_file_name=""): # Default values self.gain_db = 30 self.squelch_db = -60 self.volume_db = 0 self.threshold_db = 10 self.record = record self.spectrum = [] self.lockout_channels = [] self.gui_tuned_channels = [] self.gui_lockout_channels = [] self.channel_spacing = 5000 self.lockout_file_name = lockout_file_name # Create receiver object self.receiver = recvr.Receiver(ask_samp_rate, num_demod, hw_args, record) # Get the hardware sample rate and center frequency self.samp_rate = self.receiver.samp_rate self.center_freq = self.receiver.center_freq # Start the receiver and wait for samples to accumulate self.receiver.start() time.sleep(1)
def __init__(self, ask_samp_rate=4E6, num_demod=4, type_demod=0, hw_args="uhd", freq_correction=0, record=True, lockout_file_name="", priority_file_name="", play=True, audio_bps=8): # Default values self.gain_db = 0 self.if_gain_db = 16 self.bb_gain_db = 16 self.squelch_db = -60 self.volume_db = 0 self.threshold_db = 10 self.record = record self.play = play self.spectrum = [] self.lockout_channels = [] self.priority_channels = [] self.gui_tuned_channels = [] self.gui_lockout_channels = [] self.channel_spacing = 5000 self.lockout_file_name = lockout_file_name self.priority_file_name = priority_file_name # Create receiver object self.receiver = recvr.Receiver(ask_samp_rate, num_demod, type_demod, hw_args, freq_correction, record, play, audio_bps) # Get the hardware sample rate and center frequency self.samp_rate = self.receiver.samp_rate self.center_freq = self.receiver.center_freq # Start the receiver and wait for samples to accumulate self.receiver.start() time.sleep(1)
def test_decode_iss_packet(user, serial_number): fs, sig = waveread("test_files/ISSpkt.wav") r = receiver.Receiver(user, serial_number, fs=fs) packets = r.parse_data(sig) decode_packets(packets) expected = 1 utils.print_msg("Found {} packet. Expected {}".format(found, expected), DEBUG) r.terminate()
def main(): q = queue.Queue() s = sender.Sender(q) r = receiver.Receiver(q) s.start() r.start() while True: time.sleep(1)
def receiver_main(user, serial_number, file_path): r = receiver.Receiver(user, serial_number, baud=1200, mark_f=1200, space_f=2200) r.record(file_path) data = utils.gzip_to_data(file_path + ".gz") im = JPEG.JPEG_decompression(data) misc.imsave(file_path + "_dc.tiff", im)
def __init__(self, address, port, on_message): self.address = address self.port = port ws = create_connection("ws://" + address + ":" + port) # Create Sender and receiver self.snder = sender.Sender(ws) self.recver = receiver.Receiver(ws, on_message) # Launch both self.recver.start()
def do_login(): username = request.args.get('username') password = request.args.get('password') s = sender.Sender('login') s.sendtoRabbitMq({'username': username, 'password': password}) rec = receiver.Receiver('login') r = rec.getMessages() if r == False: return '{"status":"error","message":"Username or password not found"}' return '{"status":"ok","message":"' + str(r) + '"}'
def run(): print("Hi, I am the simple brain") relay = relay_communicator.RelayCommunicator() received_signal = receiver.Receiver() while 1: #activation_request = received_signal.check_input_from_keyboard() activation_request = received_signal.check_engage_switch() print("Activation request = ", activation_request) relay.activate(activation_request) print("sleep") time.sleep(0.4) print("Exit Program!")
def test_decode_mult_iss_packets(user, serial_number): fs, sig = waveread("test_files/ISS.wav") r = receiver.Receiver(user, serial_number, fs=fs) packets = r.parse_data(sig) decode_packets(packets) found = len( filter( lambda ax: ax.info != 'bad packet', map(r.tnc.decodeAX25, filter(lambda pkt: len(pkt) > 200, packets)))) expected = 24 utils.print_msg("Found {} packet. Expected {}".format(found, expected), DEBUG) r.terminate()
def do_registration(): UserName = request.args.get('username') Email = request.args.get('email') Password = request.args.get('password') Address = request.args.get('address') ContactNo = request.args.get('contactNo') # Send this data to RabbitMQ s = sender.Sender('registration') s.sendtoRabbitMq({'UserName': UserName, 'Email': Email, 'Password': Password, 'Address': Address, 'ContactNo': ContactNo}) rec = receiver.Receiver('registration') r = rec.getMessages() if r == False: return '{"status":"error","message":"This user may already exists"}' return '{"status":"ok","message":"User has been registered!"}'
def __init__(self, debug_queue, error_queue, address, learning, iteration, trajectory): (self.controller_address, self.receiver_address) = address self.debug_queue = debug_queue self.error_queue = error_queue self.learning = learning self.iterations = iteration self.trajectories = trajectory # The default command that is sent to the drone. self.default_cmd = { 'X': 0.0, 'Y': 0.0, 'Z': 0.0, 'R': 0.0, 'C': 0, 'T': False, 'L': False, 'S': False } # The drone's address and ports. self.drone_address = '192.168.1.1' self.ports = {'NAVDATA': 5554, 'VIDEO': 5555, 'CMD': 5556} # The drone's cameras. self.cameras = {'FRONT': 0, 'BOTTOM': 3, 'CUSTOM': 4} self.active_camera = self.cameras['FRONT'] # The method of tracking we are going to use. self.tracking = None # Initialize all modules. self.remote = remote.Remote(self.debug_queue, self.error_queue) self.controller = controller.Controller(self.debug_queue, self.error_queue) self.receiver = receiver.Receiver(self.debug_queue, self.error_queue) camera_address = 'tcp://' + self.drone_address + ':' + str( self.ports['VIDEO']) self.image_queue = Queue.Queue(maxsize=1) self.camera = camera.Camera(self.debug_queue, self.error_queue, camera_address, self.image_queue) self.camera.daemon = True self.camera.start()
async def do_work(): relay = relay_communicator.RelayCommunicator() received_signal = receiver.Receiver() alarm_bot = SlackAlarmBot() while 1: #activation_request = received_signal.check_input_from_keyboard() slack_request = alarm_bot.check_input_dummy() switch_request = received_signal.check_engage_switch() if slack_request: activation_request = slack_request else: activation_request = switch_request print("Activation request = ", activation_request) relay.activate(activation_request) print("sleep") await asyncio.sleep(0.4)
def listen(self): synpacket, cliAddr = self.sockd.recvfrom(2048) self.clientPort = cliAddr[1] head = helpers.unpackHeader(synpacket) #header = packet.Header(head) # check that received packet has SYN flag set print head assert head[SYNF] == 1, "Invalid packet -- not SYN" # set ACK number from client sequence number self.lastack = head[SEQNUM] + 1 # connect with client print("connect to " + str(cliAddr)) self.sockd.connect(cliAddr) # instantiate sender/receiver self.sender = sender.Sender(self.sockd) self.receiver = receiver.Receiver(self) self.SYNReceived()
def __init__(self, address, port, on_message): self.address = address self.port = port while True: try: ws = create_connection("ws://" + address + ":" + port) except ConnectionRefusedError: log.warn("Unable to connect to CC") time.sleep(5) continue log.info("Connection established to CC") break # Create Sender and receiver self.snder = sender.Sender(ws) self.recver = receiver.Receiver(ws, on_message) # Launch both self.recver.start()
def __init__(self, port=DEFAULT_PORT): super().__init__(caption=f"oscosc (port {port})", resizable=True) self.y_per_div = 0.5 self.time_per_div = 0.5 self.y_per_div_selected = 3 self.time_per_div_selected = 3 self.num_divs_v = 8 self.num_divs_h = 10 self.grid_color = (0.7, 0.7, 0.7) self.lines = dict() self.line_colors = dict() self.gui_width = 0 # Use timestamp of the first received OSC message or bundle as t=0 self.time_offset = 0.0 self.time_offset_ready = False self.start_time = 0.0 # List of OSC addresses received self.addresses = set() # launch receiver thread self.receiver = receiver.Receiver() self.receiver.start_thread(port) # Initialize IMGUI for pyglet # (See https://github.com/swistakm/pyimgui/blob/master/doc/examples/integrations_pyglet.py) imgui.create_context() self.imgui_renderer = PygletRenderer(self) pyglet.clock.schedule_interval(self.update, 1 / 60)
import time import receiver if __name__ == '__main__': recv = receiver.Receiver() recv.start_thread(12345) try: print('Press Ctrl-C to stop') while True: while recv.available(): msgs = recv.get() print(msgs) time.sleep(1 / 60) finally: recv.stop_thread()
def __init__(self, ask_samp_rate=4E6, num_demod=4, type_demod=0, hw_args="uhd", freq_correction=0, record=True, lockout_file_name="", priority_file_name="", channel_log_file_name="", channel_log_timeout=15, play=True, audio_bps=8, max_demod_length=0, channel_spacing=5000, min_file_size=0, center_freq=0, freq_low=0, freq_high=2000000000): # Default values self.squelch_db = -60 self.volume_db = 0 self.threshold_db = 10 self.record = record self.play = play self.audio_bps = audio_bps self.freq_low = freq_low self.freq_high = freq_high self.center_freq = center_freq self.spectrum = [] self.lockout_channels = [] self.priority_channels = [] self.active_channels = [] self.gui_tuned_channels = [] self.gui_active_channels = [] self.gui_lockout_channels = [] self.channel_spacing = channel_spacing self.lockout_file_name = lockout_file_name self.priority_file_name = priority_file_name self.channel_log_file_name = channel_log_file_name self.channel_log_file = None self.channel_log_timeout = channel_log_timeout self.log_recent_channels = [] self.log_timeout_last = int(time.time()) self.log_mode = "" self.max_demod_length = max_demod_length self.min_file_size = min_file_size self.low_bound = freq_low self.high_bound = freq_high self.hang_time = 1.0 # Create receiver object self.receiver = recvr.Receiver(ask_samp_rate, num_demod, type_demod, hw_args, freq_correction, record, play, audio_bps, min_file_size) # Set the initial center frequency here to allow setting min/max and low/high bounds self.receiver.set_center_freq(center_freq) # Open channel log file for appending data, if it is specified if channel_log_file_name != "": self.channel_log_file = open(channel_log_file_name, 'a') if self.channel_log_file != None: self.log_mode = "file" else: # Opening log file failed so cannot perform this log mode # Either raise exception or continue without logging, second preferable self.log_mode = "none" #raise(LogError("file","Cannot open log file")) else: self.channel_log_file = None # Get the hardware sample rate and center frequency in Hz self.samp_rate = self.receiver.samp_rate self.center_freq = self.receiver.center_freq self.min_freq = (self.center_freq - self.samp_rate/2) self.max_freq = (self.center_freq + self.samp_rate/2) # cannot set channel freq lower than min sampled freq if (self.freq_low < self.min_freq): self.freq_low = self.min_freq # cannot set channel freq higher than max sampled freq if (self.freq_high > self.max_freq): self.freq_high = self.max_freq self.low_bound = self.freq_low - self.center_freq self.high_bound = self.freq_high - self.center_freq # Start the receiver and wait for samples to accumulate self.receiver.start() time.sleep(1) if self.channel_log_file != None : self.channel_log_file.flush()
def __init__(self): self.receiver = receiver.Receiver(1, 1)
import tkinter as tk import tkinter.messagebox import random import sender import receiver import time import threading import communication import utils sender = sender.Sender() receiver = receiver.Receiver() class GameBoard(tk.Frame): def __init__(self, parent, rows=3, columns=3, size=128, color1="white", color2="blue"): '''size is the size of a square, in pixels''' self.rows = rows self.columns = columns self.size = size self.color1 = color1 self.color2 = color2 self.pieces = {}
def __init__(self, num): self.num = num self.receiver = receiver.Receiver(0, num) self.sender = sender.Sender(1, num)
def __init__(self): self.logger = logger.Logger() self.receiver = receiver.Receiver(self.logger)
def __init__(self): super().__init__() self.setWindowTitle('Rendt Receiver Demo') self.setWindowIcon( QtGui.QIcon('../../assets/img/rendt_new_logo_square.png')) self.resize(421, 283) self.setStyleSheet("QPushButton {\n" " background: rgb(232, 232, 232);\n" " border: 1px solid rgb(227, 227, 227);\n" "}\n" "\n" "QPushButton:hover {\n" " background: rgb(200, 200, 200);\n" "}\n" "\n" "QPushButton:pressed {\n" " background: rgb(150, 150, 150);\n" "}\n" "\n" "QWidget {\n" " background: rgb(120, 120, 120);\n" "}\n" "\n" "") # Setting up the layout self.layout = QVBoxLayout() # Setting up the 'Received Files' label self.label = QLabel(self) self.label.setText('Received Output') self.label.setGeometry(QtCore.QRect(30, 20, 210, 43)) font = QtGui.QFont() font.setFamily("Arial") font.setPointSize(36) self.label.setFont(font) self.label.setStyleSheet("color: white;") self.label.setObjectName("label") self.label.adjustSize() # Setting up output frame self.outputFrame = OutputFrame(self) self.outputFrame.setGeometry(QtCore.QRect(30, 70, 361, 121)) # Setting up output label self.outputLabel = QLabel(self.outputFrame) self.outputLabel.setStyleSheet('color: white') font = QtGui.QFont() font.setFamily('Arial') font.setPointSize(12) self.outputLabel.setFont(font) # Adding the 'Accept' button and configuring it self.acceptBtn = QPushButton(self) self.acceptBtn.setGeometry(QtCore.QRect(320, 200, 71, 31)) self.acceptBtn.setText('Accept') font = QtGui.QFont() font.setFamily("Arial") font.setPointSize(12) self.acceptBtn.setFont(font) self.acceptBtn.setStyleSheet("color: white;") self.acceptBtn.setObjectName("acceptBtn") # Setting up Waiting Screen self.waitingWindow = WaitingWindow(self) # Adding everything into the layout self.layout.addWidget(self.waitingWindow) self.layout.addWidget(self.acceptBtn) self.layout.addWidget(self.outputFrame) self.layout.addWidget(self.label) # Creating an instance of Receiver class self.receiver = receiver.Receiver() self.acceptBtn.clicked.connect(self.execFile) # Hiding the unnecessary parts self.acceptBtn.hide() self.label.hide() self.outputFrame.hide() self.outputFrame.receiveFiles()
import receiver import station import numpy as np s = station.Station(station.raspi1_noimu) s.write_event(s.min + s.max * np.random.random(s.max.size)) r = receiver.Receiver(receiver.soapy1) r.enable() print(r.read())
def setUp(self): self._receiver = receiver.Receiver()
def rev(name): # print('Run task %s (%s)...' % (name, os.getpid())) # start = time.time() # end = time.time() my_Receive = receiver.Receiver(4,1,20e3,1e3) print(my_Receive.RF_launch())
def test_image(user, serial_number): """ loop back mode """ # setup variables for tests callsign = "KK6MRI" fname = "calBlue.tiff" dir = "images/" f = open(dir + fname, "rb") fs = 48000 Abuffer = 1024 Nchunks = 12 # prepare transmitter and receiver t = transmitter.Transmitter(user, serial_number, fs=fs, Abuffer=Abuffer, Nchunks=Nchunks) r = receiver.Receiver(user, serial_number, fs=fs, Abuffer=Abuffer, Nchunks=Nchunks) # prepare i/o queues Qin = Queue.Queue() Qout = Queue.Queue() # create a control fifo to kill threads when done cQin = Queue.Queue() cQout = Queue.Queue() # create a pyaudio object p = pyaudio.PyAudio() # initialize a recording thread. t_rec = threading.Thread(target=aprs.record_audio, args=(Qin, cQin, p, fs, r.dusb_in)) t_play = threading.Thread(target=aprs.play_audio, args=(Qout, cQout, p, fs, t.dusb_out)) # generate packets and put into output queue Qout = t.generate_packets(Qout, callsign) # start the recording and playing threads t_rec.start() time.sleep(2) t_play.start() starttime = time.time() # process packets and put them into input queue r.process_packets(Qin, file_path) utils.print_msg(time.time() - starttime, DEBUG) cQout.put("EOT") cQin.put("EOT") t.terminate() r.terminate()