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."
