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