class DragonCorrectionDialog():
def __init__(self, heard):
self.completed = False
self.setup_XMLRPC_server()
dlg = wx.TextEntryDialog(None, "Correct with...", caption="Correction Dialog", defaultValue=heard)
dlg.ShowModal()
self.correction = dlg.GetValue()
self.completed = True
# start server, tk main loop
def start_server():
while not self.server_quit:
self.server.handle_request()
Timer(1, start_server).start()
# backup plan in case for whatever reason Dragon doesn't shut it down:
Timer(60, self.xmlrpc_kill).start()
def setup_XMLRPC_server(self):
self.server_quit = 0
self.server = SimpleXMLRPCServer(("127.0.0.1", LISTENING_PORT), allow_none=True)
self.server.register_function(self.xmlrpc_get_message, "get_message")
self.server.register_function(self.xmlrpc_kill, "kill")
def xmlrpc_kill(self):
self.server_quit = 1
os.kill(os.getpid(), signal.SIGTERM)
def xmlrpc_get_message(self):
print "get message called"
if self.completed:
Timer(1, self.xmlrpc_kill).start()
return self.correction
else:
return None
def __init__(self, registerInstance, server_address, keyFile=DEFAULTKEYFILE,
certFile=DEFAULTCERTFILE, caFile = DEFAULTCAFILE, logRequests=True):
"""Secure Documenting XML-RPC server.
It it very similar to DocXMLRPCServer but it uses HTTPS for transporting XML data.
"""
SimpleXMLRPCServer.__init__(self, server_address, SecureXMLRPCRequestHandler, logRequests)
self.logRequests = logRequests
self.register_introspection_functions()
# init stuff, handle different versions:
try:
SimpleXMLRPCDispatcher.__init__(self)
except TypeError:
# An exception is raised in Python 2.5 as the prototype of the __init__
# method has changed and now has 3 arguments (self, allow_none, encoding)
SimpleXMLRPCDispatcher.__init__(self, False, None)
SocketServer.BaseServer.__init__(self, server_address, SecureXMLRPCRequestHandler)
self.register_instance(registerInstance) # for some reason, have to register instance down here!
# SSL socket stuff
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file(keyFile)
ctx.use_certificate_file(certFile)
# verify
ctx.load_verify_locations(caFile)
ctx.set_verify(SSL.VERIFY_PEER|SSL.VERIFY_FAIL_IF_NO_PEER_CERT, self._verify)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
# requests count and condition, to allow for keyboard quit via CTL-C
self.requests = 0
self.rCondition = Condition()
def main():
try:
opts, args = getopt.getopt(sys.argv[1:], "hs:p:", ["help"])
serv = "localhost"
port = 8088
for opt, val in opts:
if opt in ("-h", "--help"):
usage()
sys.exit(0)
elif opt == "-s":
serv = val
elif opt == "-p":
port = int(val)
server = SimpleXMLRPCServer((serv, port), RequestHandler, True, True)
server.register_introspection_functions()
server.serve_forever()
except getopt.GetoptError as err:
print str(err)
usage()
sys.exit(1)
except ValueError:
usage()
sys.exit(1)
except KeyboardInterrupt:
sys.exit(0)
def system_listMethods(self):
methods = self.funcs.keys()
if self.instance is not None:
if hasattr(self.instance, '_listMethods'):
methods = SimpleXMLRPCServer.remove_duplicates(
methods + list_public_methods(self.instance)
)
elif not hasattr(self.instance, '_dispatch'):
methods = SimpleXMLRPCServer.remove_duplicates(
methods + list_public_methods(self.instance))
def __init__(self, password, hostname, port, server_list):
self.password = password
self.myUrl = "http://" + hostname + ":" + port
self.server_list = server_list
servers = self.update_server_list()
if servers:
for server in self.aug_network(servers[0]):
self.aug_network(server)
server = SimpleXMLRPCServer((hostname, int(port)))
if not server.register_function(self.handle_request, "handle_request"):
utils.srv(server)
class Receptive_XML_RPC(Thread):
def __init__(self, my_host, my_port, GUI_functions):
Thread.__init__(self)
self.host = my_host
# server XMLRPC
i = 0
while 1:
try:
self.server = SimpleXMLRPCServer((self.host, my_port + i))
break
except:
i += 1
self.port = my_port + i
# functions callable by the GUI
self.server.register_instance(GUI_functions)
# getPort --------------------
def getPort(self):
return self.port
# getClass --------------------
def getClass(self, host, port):
return Emissive_XML_RPC(host, port)
# kill --------------------
def kill(self):
# Send a message to awake it.
try:
url = str(self.host) + ":"+str(self.port)
newServer = xmlrpclib.Server(url)
newServer.isAlive()
except :
pass
# run --------------------
def run(self):
""" Receive messages from the GUI and process them"""
while globalvars.ALIVE:
self.server.handle_request()
print "End of Xml connection..."
class ServerThread( threading.Thread ) :
def __init__( self, case ) :
self.case = case
threading.Thread.__init__( self )
print "starting local Ophidian server..."
self.ProblemServer = ophidian.ProblemServer()
self.ProblemServer.RunDir = 'RunDir'
# check the run directory for cached problems
self.ProblemServer.InitProblemList()
# load the first problem, if it exists, exit otherwise
if self.ProblemServer.ProblemList.__contains__(case) :
self.ProblemServer.ProblemList = [case]
print "Loading CUBE data for problem " + case
self.ProblemServer.LoadProblem( case )
print "Starting server..."
self.server = SimpleXMLRPCServer(('127.0.0.1', 8000 ))
self.server.register_function(self.ProblemServer.GetProblem)
self.server.register_function(self.ProblemServer.GetBlock)
self.server.register_function(self.ProblemServer.CheckInBlock)
else :
print "No problems found. Ophidian server shutting down."
def run( self ) :
print "Now serving problem " + self.ProblemServer.Problem.problemname
self.server.serve_forever()
def _dispatch(self, method, params, **kwargs):
"""Dispatch a rpc call to the appropriate method with parameters.
This method is copied from SimpleXMLRPCServer but adds
kwargs so that REST methods can receive keyword arguments
rather than just list of parameters, which is all XMLRPC supports.
Args:
method: string, method name
params: tuple, list of arguments
kwargs: optional, dict of keyword arguments
Returns:
output from the called method
Raises:
Exception: if unsupported method is called
"""
func = None
try:
func = self.funcs[method]
except KeyError:
if self.instance is not None:
if hasattr(self.instance, '_dispatch'):
return self.instance._dispatch(method, params, kwargs)
else:
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
method,
self.allow_dotted_names)
except AttributeError:
pass
if func is not None:
return func(*params, **kwargs)
else:
raise Exception('method "%s" is not supported' % method)
def setup_XMLRPC_server(self):
self.server_quit = 0
comm = Communicator()
self.server = SimpleXMLRPCServer(("127.0.0.1", comm.com_registry["status"]), allow_none=True)
self.server.register_function(self.xmlrpc_kill, "kill")
self.server.register_function(self.xmlrpc_hint, "hint")
self.server.register_function(self.xmlrpc_text, "text")
def _dispatch(self, method, params):
func = None
try:
func = self.funcs[method]
except KeyError:
if self.instance is not None:
if hasattr(self.instance, '_dispatch'):
return self.instance._dispatch(method, params)
else:
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
method,
True
)
except AttributeError:
pass
if func is not None:
try:
if type(params) is types.ListType:
response = func(*params)
else:
response = func(**params)
return response
except TypeError:
return Fault(-32602, 'Invalid parameters: ')
except:
err_lines = traceback.format_exc().splitlines()
trace_string = '%s | %s' % (err_lines[-3], err_lines[-1])
fault = jsonrpclib.Fault(-32603, 'Server error: %s' %
trace_string)
return fault
else:
return Fault(-32601, 'Method %s not supported.' % method)
def list_public_methods(obj):
"""Returns a list of attribute strings, found in the specified
object, which represent callable attributes"""
methods = SimpleXMLRPCServer.list_public_methods(obj)
methods = [dotify(m) for m in methods if is_public(getattr(obj, m, None))]
return methods
def _dispatch(self, method, params):
func = None
try:
func = self.funcs[method]
except KeyError:
if self.instance is not None:
if hasattr(self.instance, "_dispatch"):
return self.instance._dispatch(method, params)
else:
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(self.instance, method, True)
except AttributeError:
pass
if func is not None:
try:
if type(params) is types.ListType:
# MODIFIED to pass service method name as well
response = func(method, *params)
else:
# MODIFIED to pass service method name as well
response = func(method, **params)
return response
except TypeError:
return Fault(-32602, "Invalid parameters.")
except:
err_lines = traceback.format_exc().splitlines()
trace_string = "%s | %s" % (err_lines[-3], err_lines[-1])
fault = jsonrpclib.Fault(-32603, "Server error: %s" % trace_string)
return fault
else:
return Fault(-32601, "Method %s not supported." % method)
def _dispatch(self, method, params):
"""Dispatches the XML-RPC method.
XML-RPC calls are forwarded to a registered function that
matches the called XML-RPC method name. If no such function
exists then the call is forwarded to the registered instance,
if available.
If the registered instance has a _dispatch method then that
method will be called with the name of the XML-RPC method and
its parameters as a tuple
e.g. instance._dispatch('add',(2,3))
If the registered instance does not have a _dispatch method
then the instance will be searched to find a matching method
and, if found, will be called.
Methods beginning with an '_' are considered private and will
not be called.
"""
func = None
try:
# check to see if a matching function has been registered
func = self.funcs[method]
except KeyError:
if self.instance is not None:
# check for a _dispatch method
if hasattr(self.instance, '_dispatch'):
return self.instance._dispatch(method, params)
else:
# call instance method directly
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
method,
self.allow_dotted_names
)
except AttributeError:
pass
if func is not None:
try:
# since we are using a keyword xmlrpc proxy this is sending
# the info comes in form of args and kwargs
# so params has 2 items, the first being a list or tuple
# and the second a dictionary
if len(params) == 2 and isinstance(params[1],dict) and\
( isinstance(params[0],list) or isinstance(params[0],tuple) ) :
return func(*params[0], **params[1])
else:
# this is the default way in case a normal xmlrpclib.ServerProxy is used
return func(*params)
except Exception:
# extended functionality to let the client have the full traceback
msg = traceback.format_exc()
raise xmlrpclib.Fault(1, msg)
else:
raise Exception('method "%s" is not supported' % method)
def __init__(self) :
Thread.__init__(self)
self.n = 0
self.uniqueRequests = []
self.numDoneSent = 0
self.server = SimpleXMLRPCServer(("0.0.0.0", port))
self.server.register_function(self.nextInput, "nextInput")
self.lock = Lock()
def setup_XMLRPC_server(self):
self.server_quit = 0
comm = Communicator()
self.server = SimpleXMLRPCServer(("127.0.0.1", comm.com_registry["hmc"]), allow_none=True)
self.server.register_function(self.xmlrpc_do_action, "do_action")
self.server.register_function(self.xmlrpc_complete, "complete")
self.server.register_function(self.xmlrpc_get_message, "get_message")
self.server.register_function(self.xmlrpc_kill, "kill")
def test_dotted_attribute(self):
# Raises an AttributeError because private methods are not allowed.
self.assertRaises(AttributeError, SimpleXMLRPCServer.resolve_dotted_attribute, str, "__add")
self.assertTrue(SimpleXMLRPCServer.resolve_dotted_attribute(str, "title"))
# Get the test to run faster by sending a request with test_simple1.
# This avoids waiting for the socket timeout.
self.test_simple1()
def setup_XMLRPC_server(self):
self.server_quit = 0
comm = Communicator()
self.server = SimpleXMLRPCServer(("127.0.0.1", comm.com_registry["sticky_list"]), allow_none=True)
self.server.register_function(self.xmlrpc_kill, "kill")
self.server.register_function(self.xmlrpc_add_symbol, "add_symbol")
self.server.register_function(self.xmlrpc_remove_symbol, "remove_symbol")
self.server.register_function(self.xmlrpc_clear, "clear")
def _dispatch(self, method, params):
try:
self.local.method = method
return SimpleXMLRPCServer._dispatch(self, method, params)
except:
logging.exception('Exception in method %s', method)
self.local.exception = utils.FormatExceptionOnly()
raise
def main():
print ("init")
server = SimpleXMLRPCServer(('0.0.0.0', int(SLAVE_DAEMON_PORT)))
server.register_introspection_functions()
server.register_instance(Node())
print ("starting server")
server.serve_forever()
def main(self):
msj=""
host, port = "192.168.9.30", 9990
host, port = "localhost", 4321
sock=socket.socket()
sock.connect((host,port))
self.menu(sock)
self.clienteRemoto = SimpleXMLRPCServer((localhost, 4321),allow_none=True); #aqui abre los puertos para escuchar
self.clienteRemoto.register_function(self.horaClienteLocal, "horaCliente")
class Network(object):
def __init__(self, config,log):
self.log = log
xmlport = config.getValue("xmlport")
xmlhost = config.getValue("xmlhost")
udpport = config.getValue("udpport")
udphost = config.getValue("udphost")
self.xml = SimpleXMLRPCServer((xmlhost, xmlport))
self.udp = netServer(udphost,udpport,log)
log.StartupMessage("* Attempting to start XML-RPC Server")
self.udp.serve_forever()
self.xmlThread = Thread( target = self.startXMLRPCServer )
self.xmlThread.setDaemon( True )
self.xmlThread.start()
log.StartupMessage( " XML-RPC Server is up at port %d" % xmlport)
def register_function(self,func,funcname):
self.xml.register_function(func,funcname)
self.udp.register_function(func,funcname)
self.log.Notice("Registered funtion %s for network access" % funcname)
def stopServices(self):
self.udp.stopServer()
self.udp.join()
self.log.StartupMessage("* Attempting to stop XML-RPC Server")
self.xml.server_close()
#self.xmlThread.join()
def startXMLRPCServer(self):
self.xml.serve_forever()
def system_listMethods(self):
"""system.listMethods() => ['add', 'subtract', 'multiple']
Returns a list of the methods supported by the server."""
methods = self.funcs.keys()
if self.instance is not None:
# Instance can implement _listMethods to return a list of
# methods
if hasattr(self.instance, '_listMethods'):
methods = SimpleXMLRPCServer.remove_duplicates(
methods + self.instance._listMethods()
)
# if the instance has a _dispatch method then we
# don't have enough information to provide a list
# of methods
elif not hasattr(self.instance, '_dispatch'):
methods = SimpleXMLRPCServer.remove_duplicates(
methods + list_public_methods(self.instance)
)
methods.sort()
return methods
def _dispatch(self, method, params):
"""
Default method resolver and caller
:param method: Name of the method to call
:param params: List of arguments to give to the method
:return: The result of the method
"""
func = None
try:
# Try with registered methods
func = self.funcs[method]
except KeyError:
if self.instance is not None:
# Try with the registered instance
if hasattr(self.instance, '_dispatch'):
# Instance has a custom dispatcher
return self.instance._dispatch(method, params)
else:
# Resolve the method name in the instance
try:
func = xmlrpcserver.resolve_dotted_attribute(\
self.instance, method, True)
except AttributeError:
# Unknown method
pass
if func is not None:
try:
# Call the method
if type(params) is utils.ListType:
return func(*params)
else:
return func(**params)
except TypeError as ex:
# Maybe the parameters are wrong
return Fault(-32602, 'Invalid parameters: {0}'.format(ex))
except:
# Method exception
err_lines = traceback.format_exc().splitlines()
trace_string = '{0} | {1}'.format(err_lines[-3], err_lines[-1])
return Fault(-32603, 'Server error: {0}'.format(trace_string))
else:
# Unknown method
return Fault(-32601, 'Method {0} not supported.'.format(method))
class servidor:
"""main class"""
configuraciones = {'puerto':6051, 'version_cliente':0.1,'version_server':0.1}
def __init__(self):
#self.leer_configuraciones()
#oldstderr=sys.stderr
sys.stderr=file('infoserver.log', 'w')
self.server = SimpleXMLRPCServer(("", self.configuraciones['puerto']))
cpu_datos = allocate_lock()
cpu_datos.acquire()
cpu_da = [0,0]
cpu_datos.release()
self.server.register_instance(sesiones(cpu_datos,cpu_da))
a = cpu_datos,cpu_da
start_new_thread(cpu_funcion, a)
def run(self):
self.server.serve_forever()
class RPCServer(Thread) :
def __init__(self) :
Thread.__init__(self)
self.n = 0
self.uniqueRequests = []
self.numDoneSent = 0
self.server = SimpleXMLRPCServer(("0.0.0.0", port))
self.server.register_function(self.nextInput, "nextInput")
self.lock = Lock()
def nextInput(self, ip) :
self.lock.acquire()
if self.uniqueRequests.count(ip) == 0 : self.uniqueRequests.append(ip)
if self.n >= len(input_files) :
self.numDoneSent += 1
if self.numDoneSent >= len(self.uniqueRequests) : shutdown(1)
self.lock.release()
return -1
rtn = self.n
self.n += 1
self.lock.release()
return rtn
def run(self) :
self.server.serve_forever()
def __init__(self):
#self.leer_configuraciones()
#oldstderr=sys.stderr
sys.stderr=file('infoserver.log', 'w')
self.server = SimpleXMLRPCServer(("", self.configuraciones['puerto']))
cpu_datos = allocate_lock()
cpu_datos.acquire()
cpu_da = [0,0]
cpu_datos.release()
self.server.register_instance(sesiones(cpu_datos,cpu_da))
a = cpu_datos,cpu_da
start_new_thread(cpu_funcion, a)
def my_dispatch(self, methodName, params, auth, client_addr):
"""Dispatches the XML-RPC method.
XML-RPC calls are forwarded to a registered function that
matches the called XML-RPC method name. If no such function
exists then the call is forwarded to the registered instance,
if available.
If the registered instance has a _dispatch method then that
method will be called with the name of the XML-RPC method,
its parameters as a tuple
e.g. instance._dispatch('add',(2,3))
If the registered instance does not have a _dispatch method
then the instance will be searched to find a matching method
and, if found, will be called.
Methods beginning with an '_' (except _dispatch) are considered
private and will not be called.
"""
kwdargs = {}
func = None
# check for a _dispatch method
if (self.instance is not None) and hasattr(self.instance, '_dispatch'):
return self.instance._dispatch(methodName, params, kwdargs,
auth, client_addr)
try:
# check to see if a matching function has been registered
func = self.funcs[methodName]
except KeyError:
if self.instance is not None:
# call instance method directly
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
methodName,
self.allow_dotted_names
)
except AttributeError:
pass
if func is not None:
return func(*params, **kwdargs)
else:
raise Error('method "%s" is not supported' % methodName)
def __init__(self, protocol, address, port, decks, total, packsize):
SyncEntity.__init__(self, decks, total, packsize)
self.address = address
self.port = port
self.protocol = protocol
if protocol == 'xml-rpc':
from SimpleXMLRPCServer import SimpleXMLRPCServer
server = SimpleXMLRPCServer((address, port), allow_none=True)
elif protocol == 'json-rpc':
#from SimpleJsonRPCServer import SimpleJSONRPCServer as Server
server = SimpleJSONRPCServer((address, port))
else:
raise RuntimeException("Unknown RPC protocol: %s" % protocol)
server.register_function(self.applyPayload)
server.register_function(self.append)
server.register_function(self.__contains__)
self.server = server
def __init__(self, config,log):
self.log = log
xmlport = config.getValue("xmlport")
xmlhost = config.getValue("xmlhost")
udpport = config.getValue("udpport")
udphost = config.getValue("udphost")
self.xml = SimpleXMLRPCServer((xmlhost, xmlport))
self.udp = netServer(udphost,udpport,log)
log.StartupMessage("* Attempting to start XML-RPC Server")
self.udp.serve_forever()
self.xmlThread = Thread( target = self.startXMLRPCServer )
self.xmlThread.setDaemon( True )
self.xmlThread.start()
log.StartupMessage( " XML-RPC Server is up at port %d" % xmlport)
def _dispatch(self, method, params):
if self.server.instance is None:
logging.error("Client without a server instance!")
raise AskgodException("Internal server error.")
# call instance method directly
func = None
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.server.instance,
method,
self.server.allow_dotted_names)
except Exception as e:
logging.info("Failed to resolv '%s': %s" % (method, e))
raise AskgodException("Unable to resolve method name.")
if not func:
logging.info("Function '%s' doesn't exist." % func)
raise AskgodException("Invalid method name.")
# Per connection data (address, DB connection, request)
client = {}
client['client_address'] = self.client_address[0]
client['db_store'] = Store(self.server.database)
client['request'] = self.request
forwarded_address = self.headers.get("X-Forwarded-For", "")
if forwarded_address:
client['client_address'] = forwarded_address
# Actually call the function
try:
retval = func(client, *params)
except not AskgodException:
logging.error(traceback.format_exc())
raise AskgodException("Internal server error.")
# Attempt to close the DB connection (if still there)
try:
client['db_store'].commit()
client['db_store'].close()
except:
pass
return retval
# python 2
import SimpleXMLRPCServer
except ImportError:
# python3
import xmlrpc.server as SimpleXMLRPCServer
class TestRhnpush(TestServer.TestServer):
def __init__(self):
TestServer.TestServer.__init__(self)
self._init_app()
def _init_app(self):
self.app = server.app.packages.Packages()
def getApp(self):
return self.app
if __name__ == "__main__":
server = TestRhnpush()
app = server.getApp()
print((app.test_login(server.getUsername(), server.getPassword())))
print((app.listChannel(['wregglej-test'], "wregglej", "bm8gv5z2")))
print((app.listChannelSource(['wregglej-test'], "wregglej", "bm8gv5z2")))
server = SimpleXMLRPCServer.SimpleXMLRPCServer(addr=('', 16000))
for func in app.functions:
print(func)
server.register_function(getattr(app, func), name="app.%s" % (func))
server.serve_forever()
def __init__(self, channel=26, channel_max=11, channel_min=11):
gr.top_block.__init__(self, "Top Block")
##################################################
# Parameters
##################################################
self.channel = channel
self.channel_max = channel_max
self.channel_min = channel_min
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 4000000
##################################################
# Blocks
##################################################
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(
('localhost', 8080), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
self.xmlrpc_server_0_thread = threading.Thread(
target=self.xmlrpc_server_0.serve_forever)
self.xmlrpc_server_0_thread.daemon = True
self.xmlrpc_server_0_thread.start()
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(('', "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(
1000000 * (2400 + 5 * (channel - 10)), 0)
self.uhd_usrp_source_0.set_gain(40, 0)
self.uhd_usrp_source_0.set_antenna('RX2', 0)
self.uhd_usrp_source_0.set_auto_dc_offset(False, 0)
self.uhd_usrp_source_0.set_auto_iq_balance(False, 0)
self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(
0.00016, 1)
self.rftap_rftap_encap_0 = rftap.rftap_encap(2, 195, '')
self.ieee802_15_4_packet_sink_0 = ieee802_15_4.packet_sink(10)
self.epy_block_0 = epy_block_0.blk()
self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff(
2, 0.000225, 0.5, 0.03, 0.0002)
self.blocks_sub_xx_0 = blocks.sub_ff(1)
self.blocks_socket_pdu_0_0_0 = blocks.socket_pdu(
"UDP_CLIENT", '127.0.0.1', '52002', 10000, False)
self.blocks_message_debug_0 = blocks.message_debug()
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(1)
##################################################
# Connections
##################################################
self.msg_connect((self.epy_block_0, 'out'),
(self.rftap_rftap_encap_0, 'in'))
self.msg_connect((self.ieee802_15_4_packet_sink_0, 'out'),
(self.blocks_message_debug_0, 'print_pdu'))
self.msg_connect((self.ieee802_15_4_packet_sink_0, 'out'),
(self.epy_block_0, 'in'))
self.msg_connect((self.rftap_rftap_encap_0, 'out'),
(self.blocks_socket_pdu_0_0_0, 'pdus'))
self.connect((self.analog_quadrature_demod_cf_0, 0),
(self.blocks_sub_xx_0, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0),
(self.single_pole_iir_filter_xx_0, 0))
self.connect((self.blocks_sub_xx_0, 0),
(self.digital_clock_recovery_mm_xx_0, 0))
self.connect((self.digital_clock_recovery_mm_xx_0, 0),
(self.ieee802_15_4_packet_sink_0, 0))
self.connect((self.single_pole_iir_filter_xx_0, 0),
(self.blocks_sub_xx_0, 1))
self.connect((self.uhd_usrp_source_0, 0),
(self.analog_quadrature_demod_cf_0, 0))
def __init__(self):
gr.top_block.__init__(self, "OFDM Single")
Qt.QWidget.__init__(self)
self.setWindowTitle("OFDM Single")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "vr1_rx")
if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"):
self.restoreGeometry(self.settings.value("geometry").toByteArray())
else:
self.restoreGeometry(
self.settings.value("geometry", type=QtCore.QByteArray))
##################################################
# Variables
##################################################
self.vr1_pc = vr1_pc = ((-27, -14, -7, 7, 14, 27), )
self.vr1_pattern2 = vr1_pattern2 = [1, -1, 1, -1]
self.vr1_pattern1 = vr1_pattern1 = [0., 1.41421356, 0., -1.41421356]
self.fft_len = fft_len = 64
self.zcpu = zcpu = psutil
self._xmlrpcport_config = ConfigParser.ConfigParser()
self._xmlrpcport_config.read('./default')
try:
xmlrpcport = self._xmlrpcport_config.getint("rx", "xmlrpcport")
except:
xmlrpcport = 0
self.xmlrpcport = xmlrpcport
self.vr1_sw2 = vr1_sw2 = [
0.,
0.,
0.,
0.,
0.,
0.,
] + vr1_pattern2 * ((fft_len - 12) / len(vr1_pattern2)) + [
0.,
0.,
0.,
0.,
0.,
0.,
]
self.vr1_sw1 = vr1_sw1 = [
0.,
0.,
0.,
0.,
0.,
0.,
] + vr1_pattern1 * ((fft_len - 12) / len(vr1_pattern1)) + [
0.,
0.,
0.,
0.,
0.,
0.,
]
self.vr1_ps = vr1_ps = ((-1, 1, 1, -1, -1, -1), )
self.vr1_oc = vr1_oc = (sorted(
tuple(
set([x for x in range(-26, 27)]) - set(vr1_pc[0]) - set([
0,
]))), )
self._usrpip_config = ConfigParser.ConfigParser()
self._usrpip_config.read('./default')
try:
usrpip = self._usrpip_config.get("usrp", "ip")
except:
usrpip = "127.0.0.1"
self.usrpip = usrpip
self._txoutport_config = ConfigParser.ConfigParser()
self._txoutport_config.read('./default')
try:
txoutport = self._txoutport_config.get("usrp", "txoutport")
except:
txoutport = "2666"
self.txoutport = txoutport
self.tx_goodput = tx_goodput = 0
self._timeout_config = ConfigParser.ConfigParser()
self._timeout_config.read('./default')
try:
timeout = self._timeout_config.getint("global", "zmqtimeout")
except:
timeout = 100
self.timeout = timeout
self._samprate_config = ConfigParser.ConfigParser()
self._samprate_config.read('./default')
try:
samprate = self._samprate_config.getfloat("usrp_hydra",
"samprate1")
except:
samprate = 4e6
self.samprate = samprate
self.rx_goodput = rx_goodput = 0
self._maxnoutput_config = ConfigParser.ConfigParser()
self._maxnoutput_config.read('./default')
try:
maxnoutput = self._maxnoutput_config.getint("global", "maxnoutput")
except:
maxnoutput = 100
self.maxnoutput = maxnoutput
self._freq_config = ConfigParser.ConfigParser()
self._freq_config.read('./default')
try:
freq = self._freq_config.getfloat("usrp_hydra", "txfreq1")
except:
freq = 4.4e9
self.freq = freq
self.cpu_percent = cpu_percent = 0
self.amplitude = amplitude = 0.01
##################################################
# Blocks
##################################################
self.probe1_1_0 = blocks.probe_rate(gr.sizeof_char * 1, 500.0, 0.15)
self.probe1_1 = blocks.probe_rate(gr.sizeof_char * 1, 500.0, 0.15)
self._amplitude_range = Range(0, 1, 0.01, 0.01, 200)
self._amplitude_win = RangeWidget(self._amplitude_range,
self.set_amplitude, 'amplitude',
"counter_slider", float)
self.top_layout.addWidget(self._amplitude_win)
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(
('127.0.0.1', xmlrpcport), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
self.xmlrpc_server_0_thread = threading.Thread(
target=self.xmlrpc_server_0.serve_forever)
self.xmlrpc_server_0_thread.daemon = True
self.xmlrpc_server_0_thread.start()
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samprate)
self.uhd_usrp_source_0.set_center_freq(freq, 0)
self.uhd_usrp_source_0.set_normalized_gain(0, 0)
self.uhd_usrp_source_0.set_antenna('RX2', 0)
self.uhd_usrp_sink_0 = uhd.usrp_sink(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_samp_rate(samprate)
self.uhd_usrp_sink_0.set_center_freq(freq + 4e6, 0)
self.uhd_usrp_sink_0.set_normalized_gain(1.0, 0)
self.uhd_usrp_sink_0.set_antenna('TX/RX', 0)
def _tx_goodput_probe():
while True:
val = self.probe1_1_0.rate()
try:
self.set_tx_goodput(val)
except AttributeError:
pass
time.sleep(1.0 / (10))
_tx_goodput_thread = threading.Thread(target=_tx_goodput_probe)
_tx_goodput_thread.daemon = True
_tx_goodput_thread.start()
def _rx_goodput_probe():
while True:
val = self.probe1_1.rate()
try:
self.set_rx_goodput(val)
except AttributeError:
pass
time.sleep(1.0 / (10))
_rx_goodput_thread = threading.Thread(target=_rx_goodput_probe)
_rx_goodput_thread.daemon = True
_rx_goodput_thread.start()
self.qtgui_waterfall_sink_x_0 = qtgui.waterfall_sink_c(
1024, #size
firdes.WIN_RECTANGULAR, #wintype
0, #fc
100, #bw
"", #name
1 #number of inputs
)
self.qtgui_waterfall_sink_x_0.set_update_time(0.10)
self.qtgui_waterfall_sink_x_0.enable_grid(False)
self.qtgui_waterfall_sink_x_0.enable_axis_labels(True)
if not True:
self.qtgui_waterfall_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_waterfall_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
colors = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_waterfall_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_waterfall_sink_x_0.set_line_label(i, labels[i])
self.qtgui_waterfall_sink_x_0.set_color_map(i, colors[i])
self.qtgui_waterfall_sink_x_0.set_line_alpha(i, alphas[i])
self.qtgui_waterfall_sink_x_0.set_intensity_range(-140, 10)
self._qtgui_waterfall_sink_x_0_win = sip.wrapinstance(
self.qtgui_waterfall_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_waterfall_sink_x_0_win)
self.digital_ofdm_tx_0 = digital.ofdm_tx(fft_len=fft_len,
cp_len=16,
packet_length_tag_key="vr1tx",
occupied_carriers=vr1_oc,
pilot_carriers=vr1_pc,
pilot_symbols=vr1_ps,
sync_word1=vr1_sw1,
sync_word2=vr1_sw2,
bps_header=1,
bps_payload=1,
rolloff=0,
debug_log=False,
scramble_bits=False)
self.digital_ofdm_rx_0 = digital.ofdm_rx(
fft_len=fft_len,
cp_len=16,
frame_length_tag_key='frame_' + "vr1rx",
packet_length_tag_key="vr1rx",
occupied_carriers=vr1_oc,
pilot_carriers=vr1_pc,
pilot_symbols=vr1_ps,
sync_word1=vr1_sw1,
sync_word2=vr1_sw2,
bps_header=1,
bps_payload=1,
debug_log=False,
scramble_bits=False)
self.digital_burst_shaper_xx_0 = digital.burst_shaper_cc(
(([])), 2000, 1000, False, "vr1tx")
def _cpu_percent_probe():
while True:
val = self.zcpu.cpu_percent()
try:
self.set_cpu_percent(val)
except AttributeError:
pass
time.sleep(1.0 / (1))
_cpu_percent_thread = threading.Thread(target=_cpu_percent_probe)
_cpu_percent_thread.daemon = True
_cpu_percent_thread.start()
self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(
blocks.byte_t, "vr1rx")
(self.blocks_tagged_stream_to_pdu_0).set_processor_affinity([1])
self.blocks_tag_debug_0_0 = blocks.tag_debug(gr.sizeof_char * 1,
"Tx'd Packet", "")
self.blocks_tag_debug_0_0.set_display(True)
self.blocks_tag_debug_0 = blocks.tag_debug(gr.sizeof_char * 1,
"Rx'd Packet", "")
self.blocks_tag_debug_0.set_display(True)
self.blocks_random_pdu_0_0 = blocks.random_pdu(100, 100, chr(0xFF), 2)
self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(
blocks.byte_t, "vr1tx")
self.blocks_pdu_set_0_0 = blocks.pdu_set(pmt.intern("vr1rx"),
pmt.intern("generate"))
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc(
(amplitude, ))
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_pdu_set_0_0, 'pdus'),
(self.blocks_random_pdu_0_0, 'generate'))
self.msg_connect((self.blocks_random_pdu_0_0, 'pdus'),
(self.blocks_pdu_to_tagged_stream_0, 'pdus'))
self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'),
(self.blocks_pdu_set_0_0, 'pdus'))
self.connect((self.blocks_multiply_const_vxx_0, 0),
(self.digital_burst_shaper_xx_0, 0))
self.connect((self.blocks_pdu_to_tagged_stream_0, 0),
(self.blocks_tag_debug_0_0, 0))
self.connect((self.blocks_pdu_to_tagged_stream_0, 0),
(self.digital_ofdm_tx_0, 0))
self.connect((self.blocks_pdu_to_tagged_stream_0, 0),
(self.probe1_1_0, 0))
self.connect((self.digital_burst_shaper_xx_0, 0),
(self.uhd_usrp_sink_0, 0))
self.connect((self.digital_ofdm_rx_0, 0), (self.blocks_tag_debug_0, 0))
self.connect((self.digital_ofdm_rx_0, 0),
(self.blocks_tagged_stream_to_pdu_0, 0))
self.connect((self.digital_ofdm_rx_0, 0), (self.probe1_1, 0))
self.connect((self.digital_ofdm_tx_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.digital_ofdm_rx_0, 0))
self.connect((self.uhd_usrp_source_0, 0),
(self.qtgui_waterfall_sink_x_0, 0))
def __init__(self):
gr.top_block.__init__(self, "VR1 TX all-in-one")
##################################################
# Variables
##################################################
self.pilot_carriers = pilot_carriers = ((-27, -14, -7, 7, 14, 27),)
self.pattern2 = pattern2 = [1, -1, 1, -1]
self.pattern1 = pattern1 = [0., 1.41421356, 0., -1.41421356]
self.fft_len = fft_len = 64
self.zcpu = zcpu = psutil
self._xmlrpcport_config = ConfigParser.ConfigParser()
self._xmlrpcport_config.read('./default')
try: xmlrpcport = self._xmlrpcport_config.getint("vr1_tx", "xmlrpcport")
except: xmlrpcport = 8081
self.xmlrpcport = xmlrpcport
self._usrpip_config = ConfigParser.ConfigParser()
self._usrpip_config.read('./default')
try: usrpip = self._usrpip_config.get("usrp_hydra", "ip")
except: usrpip = "127.0.0.1"
self.usrpip = usrpip
self._txport_config = ConfigParser.ConfigParser()
self._txport_config.read('./default')
try: txport = self._txport_config.get("vr1_tx", "port")
except: txport = "2666"
self.txport = txport
self.tx_goodput = tx_goodput = 0
self.sync_word2 = sync_word2 = [0., 0., 0., 0., 0., 0.,] + pattern2 * ((fft_len-12)/len(pattern2)) +[0., 0., 0., 0., 0., 0.,]
self.sync_word1 = sync_word1 = [0., 0., 0., 0., 0., 0.,] + pattern1 * ((fft_len-12)/len(pattern1)) +[0., 0., 0., 0., 0., 0.,]
self._samprate_config = ConfigParser.ConfigParser()
self._samprate_config.read('./default')
try: samprate = self._samprate_config.getfloat("usrp_hydra", "samprate1")
except: samprate = 0
self.samprate = samprate
self._rxport_config = ConfigParser.ConfigParser()
self._rxport_config.read('./default')
try: rxport = self._rxport_config.get("usrp_hydra", "rxport1")
except: rxport = "2666"
self.rxport = rxport
self.pilot_symbols = pilot_symbols = ((-1,1, 1, -1, -1, -1),)
self.packet_len = packet_len = 100
self.occupied_carriers = occupied_carriers = (sorted(tuple(set([x for x in range(-26,27)]) - set(pilot_carriers[0]) - set([0,]))),)
self._ip_config = ConfigParser.ConfigParser()
self._ip_config.read('./default')
try: ip = self._ip_config.get("vr1_tx", "ip")
except: ip = "127.0.0.1"
self.ip = ip
self.cpu_percent = cpu_percent = 0
##################################################
# Blocks
##################################################
self.ztxrate = blocks.probe_rate(gr.sizeof_char*1, 2000, 0.15)
self.zeromq_push_sink_0 = zeromq.push_sink(gr.sizeof_gr_complex, 1, "tcp://" + ip + ":" + txport, 100, True, -1)
self.xmlrpc_server_0_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(('127.0.0.1', xmlrpcport), allow_none=True)
self.xmlrpc_server_0_0.register_instance(self)
self.xmlrpc_server_0_0_thread = threading.Thread(target=self.xmlrpc_server_0_0.serve_forever)
self.xmlrpc_server_0_0_thread.daemon = True
self.xmlrpc_server_0_0_thread.start()
def _tx_goodput_probe():
while True:
val = self.ztxrate.rate()
try:
self.set_tx_goodput(val)
except AttributeError:
pass
time.sleep(1.0 / (10))
_tx_goodput_thread = threading.Thread(target=_tx_goodput_probe)
_tx_goodput_thread.daemon = True
_tx_goodput_thread.start()
self.digital_ofdm_tx_0 = digital.ofdm_tx(
fft_len=fft_len, cp_len=16,
packet_length_tag_key="packet_len",
occupied_carriers=occupied_carriers,
pilot_carriers=pilot_carriers,
pilot_symbols=pilot_symbols,
sync_word1=sync_word1,
sync_word2=sync_word2,
bps_header=1,
bps_payload=1,
rolloff=0,
debug_log=False,
scramble_bits=False
)
def _cpu_percent_probe():
while True:
val = self.zcpu.cpu_percent()
try:
self.set_cpu_percent(val)
except AttributeError:
pass
time.sleep(1.0 / (1))
_cpu_percent_thread = threading.Thread(target=_cpu_percent_probe)
_cpu_percent_thread.daemon = True
_cpu_percent_thread.start()
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samprate,True)
self.blocks_tag_debug_0_0 = blocks.tag_debug(gr.sizeof_char*1, "Tx'd Packet", ""); self.blocks_tag_debug_0_0.set_display(True)
self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, packet_len, "packet_len")
self.analog_random_source_x_0 = blocks.vector_source_b(map(int, numpy.random.randint(0, 255, 1000)), True)
##################################################
# Connections
##################################################
self.connect((self.analog_random_source_x_0, 0), (self.blocks_stream_to_tagged_stream_0, 0))
self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.blocks_tag_debug_0_0, 0))
self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.digital_ofdm_tx_0, 0))
self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.ztxrate, 0))
self.connect((self.blocks_throttle_0, 0), (self.zeromq_push_sink_0, 0))
self.connect((self.digital_ofdm_tx_0, 0), (self.blocks_throttle_0, 0))
import SimpleXMLRPCServer
running = True
def finis():
global running
running = False
return 1
server = SimpleXMLRPCServer.SimpleXMLRPCServer(('127.0.0.1', 8000))
server.register_function(finis)
while running:
server.handle_request()
#!/bin/bash
export UTGID
exec -a ${UTGID} /usr/bin/python <</EOF
import os, sys, socket, xmlrpclib,SimpleXMLRPCServer
class XMLRPCTestSrv:
def ping(self,who,count,size):
ti = xmlrpclib.DateTime();
return (1,2,3.,4.,'hello_0',ti,True,(11,22,33.,44.,'hello_1',False,),[111,222,333.,444.,'hello_2',ti],
{'d1':1111,'d2':2222,'d3':3333.,'d4':4444.,'ds':'hello_3'})
def log_req(self, code='-', size='-'): pass
if __name__ == "__main__":
port=8088
if len('${1}')>0:
port=int('${1}')
print 'Port:',port
server = SimpleXMLRPCServer.SimpleXMLRPCServer((socket.gethostname(),port),logRequests=False)
server.log_request = log_req
server.register_instance(XMLRPCTestSrv())
print '..... XMLRPCTest server instance is now running.....'
server.serve_forever()
/EOF
"""
get release version num
"""
return platform.release()
def get_linux_distribution(self):
'''
get info about linux distribution
'''
return platform.linux_distribution()
def get_architecture(self):
"""
return 64bit or 32bit
"""
return platform.architecture()[0]
def get_node(self):
"""
return node name
hostname
"""
return platform.node()
if __name__ == '__main__':
server = SimpleXMLRPCServer.SimpleXMLRPCServer((IP, PORT))
obj = Proc()
server.register_instance(obj)
print('rpc service start..')
server.serve_forever()
#!/usr/bin/env python
import xmlrpclib, SimpleXMLRPCServer, threading
#############
# Handle the callbacks here:
callback_handler = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", 20001))
def print_event(event_type, args, state):
print "type: %s\nargs: %s\n state: %s\n\n" % (event_type, args, state)
return True
callback_handler.register_function(print_event)
server_thread = threading.Thread(target=callback_handler.serve_forever)
server_thread.start()
############
node = xmlrpclib.ServerProxy("http://127.0.0.1:20000/xm.rem")
#setup our callback function:
node.localproxy("xmlrpc.AddXRHandler", "pytest", "http://localhost:20001/RPC2")
print node.localproxy("ConnectionTable.addConnectionHandler", \
"pytest.print_event", "my_state")
raw_input("Press Enter to quit")
#stop listening now
def main():
replica = Replica()
server = SimpleXMLRPCServer.SimpleXMLRPCServer(("", 8000), allow_none=True)
server.register_instance(replica)
print("Replica ready.")
server.serve_forever()
import SimpleXMLRPCServer
def hello():
return "Hello World Python WS"
server = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 8081))
server.register_function(hello)
print "Webservice up and running in python... "
server.serve_forever()
#!/usr/bin/env python
import SimpleXMLRPCServer
import xmlrpclib
import sys, time, os, os.path
import datetime
from remoteapp import remote_client_db, convertdata
sep = os.sep
NAME = os.environ['COMPUTERNAME']
DOMAIN = os.environ['USERDNSDOMAIN']
server_name = lower('.'.join(NAME, DOMAIN))
paths = '%s%shddlab%sPerformance_Results%s' % (sep,sep,sep,sep)
server = SimpleXMLRPCServer.SimpleXMLRPCServer((server_name,1332), logRequests=True, allow_none=True)
server.register_introspection_functions()
server.register_multicall_functions()
#file_names = ["XQV03JDA.csv", "XQV03L1A.csv", "XQV03LJA.csv", "XQV03LKA.csv", "XQV03PRA.csv", "XQV03R6A.csv"]
file_names = ["1 1.csv", "2 1.csv", "3 1.csv", "4 1.csv", "5 1.csv", "6 1.csv"]
class gateway_connect:
def __init__(self):
self.script_filenames = []
self.performance_Result_file = ''
def run_performance_testing(self, group, metrics):
"""the group list of iometer scripts are passed in to run the analysis between similar products"""
self.script_filenames = group
#paths = '%s%shddlab%sPerformance_Results%s' % (sep,sep,sep,sep)
analysis.run(file_names, paths, metrics)
def __init__(self):
gr.top_block.__init__(self, "Static RF or Single Path Rayleigh Faded RF")
Qt.QWidget.__init__(self)
self.setWindowTitle("Static RF or Single Path Rayleigh Faded RF")
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
##################################################
# Variables
##################################################
self.usrpRate = usrpRate = 250e3
self.fd = fd = 50
self.fdTs = fdTs = fd*(1.0/usrpRate)
self.fadeMode = fadeMode = False
self.centreFreq = centreFreq = 1e6
self.baseband_multiplier = baseband_multiplier = 0.25
self.atten = atten = 0
##################################################
# Blocks
##################################################
_fadeMode_check_box = Qt.QCheckBox("Fading Enabled")
self._fadeMode_choices = {True: True, False: False}
self._fadeMode_choices_inv = dict((v,k) for k,v in self._fadeMode_choices.iteritems())
self._fadeMode_callback = lambda i: _fadeMode_check_box.setChecked(self._fadeMode_choices_inv[i])
self._fadeMode_callback(self.fadeMode)
_fadeMode_check_box.stateChanged.connect(lambda i: self.set_fadeMode(self._fadeMode_choices[bool(i)]))
self.top_layout.addWidget(_fadeMode_check_box)
self._atten_layout = Qt.QVBoxLayout()
self._atten_tool_bar = Qt.QToolBar(self)
self._atten_layout.addWidget(self._atten_tool_bar)
self._atten_tool_bar.addWidget(Qt.QLabel("RF Attenuator Setting, dB"+": "))
self._atten_counter = Qwt.QwtCounter()
self._atten_counter.setRange(0, 63, 0.5)
self._atten_counter.setNumButtons(2)
self._atten_counter.setValue(self.atten)
self._atten_tool_bar.addWidget(self._atten_counter)
self._atten_counter.valueChanged.connect(self.set_atten)
self._atten_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot)
self._atten_slider.setRange(0, 63, 0.5)
self._atten_slider.setValue(self.atten)
self._atten_slider.setMinimumWidth(200)
self._atten_slider.valueChanged.connect(self.set_atten)
self._atten_layout.addWidget(self._atten_slider)
self.top_layout.addLayout(self._atten_layout)
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(("0.0.0.0", 1234), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
threading.Thread(target=self.xmlrpc_server_0.serve_forever).start()
self.uhd_usrp_sink_0_0_0 = uhd.usrp_sink(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0_0_0.set_subdev_spec("B:AB", 0)
self.uhd_usrp_sink_0_0_0.set_samp_rate(usrpRate)
self.uhd_usrp_sink_0_0_0.set_center_freq(centreFreq, 0)
self.uhd_usrp_sink_0_0_0.set_gain(0, 0)
self.rccBlocks_channelModel_cc_0 = rccBlocks.channelModel_cc(randint(-10000,0), fdTs, 1.0, False, fadeMode)
self.rccBlocks_VNXLabBrick_0 = rccBlocks.VNXLabBrick(atten)
self._fd_tool_bar = Qt.QToolBar(self)
self._fd_tool_bar.addWidget(Qt.QLabel("Doppler Rate, Hz"+": "))
self._fd_line_edit = Qt.QLineEdit(str(self.fd))
self._fd_tool_bar.addWidget(self._fd_line_edit)
self._fd_line_edit.returnPressed.connect(
lambda: self.set_fd(eng_notation.str_to_num(self._fd_line_edit.text().toAscii())))
self.top_layout.addWidget(self._fd_tool_bar)
self.const_source_x_0_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 1.0)
self.const_source_x_0 = gr.sig_source_c(0, gr.GR_CONST_WAVE, 0, 0, 1.0+1j)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float*1, usrpRate)
self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vcc((baseband_multiplier, ))
##################################################
# Connections
##################################################
self.connect((self.const_source_x_0, 0), (self.rccBlocks_channelModel_cc_0, 0))
self.connect((self.blocks_multiply_const_vxx_1, 0), (self.uhd_usrp_sink_0_0_0, 0))
self.connect((self.const_source_x_0_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.rccBlocks_VNXLabBrick_0, 0))
self.connect((self.rccBlocks_channelModel_cc_0, 0), (self.blocks_multiply_const_vxx_1, 0))
def rpc_server():
rpcserver = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 8004),
logRequests=False)
rpcserver.register_function(announce, 'announce')
logger.debug('启动xml rpc server')
rpcserver.serve_forever()
def http_multi_server(evt, numrequests, requestHandler=None):
class TestInstanceClass:
def div(self, x, y):
return x // y
def _methodHelp(self, name):
if name == 'div':
return 'This is the div function'
def my_function():
'''This is my function'''
return True
class MyXMLRPCServer(SimpleXMLRPCServer.MultiPathXMLRPCServer):
def get_request(self):
# Ensure the socket is always non-blocking. On Linux, socket
# attributes are not inherited like they are on *BSD and Windows.
s, port = self.socket.accept()
s.setblocking(True)
return s, port
if not requestHandler:
requestHandler = SimpleXMLRPCServer.SimpleXMLRPCRequestHandler
class MyRequestHandler(requestHandler):
rpc_paths = []
serv = MyXMLRPCServer(("localhost", 0),
MyRequestHandler,
logRequests=False,
bind_and_activate=False)
serv.socket.settimeout(3)
serv.server_bind()
try:
global ADDR, PORT, URL
ADDR, PORT = serv.socket.getsockname()
#connect to IP address directly. This avoids socket.create_connection()
#trying to connect to "localhost" using all address families, which
#causes slowdown e.g. on vista which supports AF_INET6. The server listens
#on AF_INET only.
URL = "http://%s:%d" % (ADDR, PORT)
serv.server_activate()
paths = ["/foo", "/foo/bar"]
for path in paths:
d = serv.add_dispatcher(
path, SimpleXMLRPCServer.SimpleXMLRPCDispatcher())
d.register_introspection_functions()
d.register_multicall_functions()
serv.get_dispatcher(paths[0]).register_function(pow)
serv.get_dispatcher(paths[1]).register_function(
lambda x, y: x + y, 'add')
evt.set()
# handle up to 'numrequests' requests
while numrequests > 0:
serv.handle_request()
numrequests -= 1
except socket.timeout:
pass
finally:
serv.socket.close()
PORT = None
evt.set()
else:
return 'Invalid Method [%s]' % method
# functions available as web services
class XMLRPC_register:
def hello_world(self, t1, t2, validuser):
if validuser:
return t1 + '-' + t2
else:
return "please register ur machine"
if __name__ == '__main__':
try:
se = SimpleXMLRPCServer(("localhost", 8088),
MySimpleXMLRPCRequestHandler, True, True)
se.register_introspection_functions()
se.serve_forever()
except KeyboardInterrupt:
print "Bye"
#--------------------- new file starts here-----------
### client.py
import os
import base64
import xmlrpclib
import urllib2
import cookielib
class CookieAuthXMLRPCTransport(xmlrpclib.Transport):
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Signal Hunter Faked")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 2000000
self.xlate_decimation = xlate_decimation = 40
self.offset2 = offset2 = 0
self.offset = offset = samp_rate / 4
self.hunter_freq_0 = hunter_freq_0 = 0
self.gain = gain = 10
self.frequency = frequency = 930000000
self.filter_width = filter_width = 5120
self.fft_taps = fft_taps = filter.firdes.low_pass_2(
1, samp_rate, 2000, 1000, 0.1)
##################################################
# Blocks
##################################################
_offset2_sizer = wx.BoxSizer(wx.VERTICAL)
self._offset2_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_offset2_sizer,
value=self.offset2,
callback=self.set_offset2,
label='offset2',
converter=forms.int_converter(),
proportion=0,
)
self._offset2_slider = forms.slider(
parent=self.GetWin(),
sizer=_offset2_sizer,
value=self.offset2,
callback=self.set_offset2,
minimum=-samp_rate / 2,
maximum=samp_rate / 2,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.Add(_offset2_sizer)
_offset_sizer = wx.BoxSizer(wx.VERTICAL)
self._offset_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_offset_sizer,
value=self.offset,
callback=self.set_offset,
label='offset',
converter=forms.int_converter(),
proportion=0,
)
self._offset_slider = forms.slider(
parent=self.GetWin(),
sizer=_offset_sizer,
value=self.offset,
callback=self.set_offset,
minimum=-samp_rate / 2,
maximum=samp_rate / 2,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.Add(_offset_sizer)
_hunter_freq_0_sizer = wx.BoxSizer(wx.VERTICAL)
self._hunter_freq_0_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_hunter_freq_0_sizer,
value=self.hunter_freq_0,
callback=self.set_hunter_freq_0,
label='hunter_freq_0',
converter=forms.int_converter(),
proportion=0,
)
self._hunter_freq_0_slider = forms.slider(
parent=self.GetWin(),
sizer=_hunter_freq_0_sizer,
value=self.hunter_freq_0,
callback=self.set_hunter_freq_0,
minimum=-100000,
maximum=100000,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.Add(_hunter_freq_0_sizer)
_frequency_sizer = wx.BoxSizer(wx.VERTICAL)
self._frequency_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_frequency_sizer,
value=self.frequency,
callback=self.set_frequency,
label='Frequency',
converter=forms.int_converter(),
proportion=0,
)
self._frequency_slider = forms.slider(
parent=self.GetWin(),
sizer=_frequency_sizer,
value=self.frequency,
callback=self.set_frequency,
minimum=80000000,
maximum=1100000000,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.Add(_frequency_sizer)
self.zeromq_push_sink_1 = zeromq.push_sink(gr.sizeof_gr_complex,
samp_rate,
'tcp://127.0.0.1:9001', 100,
False, -1)
self.zeromq_push_sink_0_0 = zeromq.push_sink(gr.sizeof_float, 1024,
'tcp://127.0.0.1:9000',
100, False, -1)
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(
('localhost', 8080), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
self.xmlrpc_server_0_thread = threading.Thread(
target=self.xmlrpc_server_0.serve_forever)
self.xmlrpc_server_0_thread.daemon = True
self.xmlrpc_server_0_thread.start()
self.wxgui_fftsink2_0_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate / xlate_decimation,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title='filtered_fft',
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0_0.win)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=frequency,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title='master_plot',
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
_gain_sizer = wx.BoxSizer(wx.VERTICAL)
self._gain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_gain_sizer,
value=self.gain,
callback=self.set_gain,
label='gain',
converter=forms.int_converter(),
proportion=0,
)
self._gain_slider = forms.slider(
parent=self.GetWin(),
sizer=_gain_sizer,
value=self.gain,
callback=self.set_gain,
minimum=0,
maximum=50,
num_steps=50,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.Add(_gain_sizer)
self.freq_xlating_fft_filter_ccc_0 = filter.freq_xlating_fft_filter_ccc(
xlate_decimation, (fft_taps), frequency + hunter_freq_0, samp_rate)
self.freq_xlating_fft_filter_ccc_0.set_nthreads(1)
self.freq_xlating_fft_filter_ccc_0.declare_sample_delay(0)
_filter_width_sizer = wx.BoxSizer(wx.VERTICAL)
self._filter_width_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_filter_width_sizer,
value=self.filter_width,
callback=self.set_filter_width,
label='filter_width',
converter=forms.int_converter(),
proportion=0,
)
self._filter_width_slider = forms.slider(
parent=self.GetWin(),
sizer=_filter_width_sizer,
value=self.filter_width,
callback=self.set_filter_width,
minimum=2048,
maximum=40960,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.Add(_filter_width_sizer)
self.fft_vxx_0 = fft.fft_vcc(1024, True, (window.blackmanharris(1024)),
True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(
gr.sizeof_gr_complex * 1, 1024)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1,
samp_rate, True)
self.blocks_stream_to_vector_2 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, samp_rate)
self.blocks_stream_to_vector_1 = blocks.stream_to_vector(
gr.sizeof_float * 1, 1024)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, 1024)
self.blocks_complex_to_real_0 = blocks.complex_to_real(1)
self.blocks_add_xx_0 = blocks.add_vcc(1)
self.analog_sig_source_x_0_0 = analog.sig_source_c(
samp_rate, analog.GR_SIN_WAVE, frequency + offset, 0.001, 0)
self.analog_sig_source_x_0 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, frequency + offset2, 0.001, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_sig_source_x_0, 0),
(self.blocks_add_xx_0, 1))
self.connect((self.analog_sig_source_x_0, 0),
(self.blocks_stream_to_vector_2, 0))
self.connect((self.analog_sig_source_x_0_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_add_xx_0, 0),
(self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_add_xx_0, 0),
(self.freq_xlating_fft_filter_ccc_0, 0))
self.connect((self.blocks_add_xx_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.blocks_complex_to_real_0, 0),
(self.blocks_stream_to_vector_1, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_stream_to_vector_1, 0),
(self.zeromq_push_sink_0_0, 0))
self.connect((self.blocks_stream_to_vector_2, 0),
(self.zeromq_push_sink_1, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_add_xx_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0),
(self.blocks_complex_to_real_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.freq_xlating_fft_filter_ccc_0, 0),
(self.wxgui_fftsink2_0_0, 0))
class HaloRPC:
def __init__(self):
"""
"""
import string
self.python_string = string
import HaloRadio
import HaloRadio.Song as Song
import HaloRadio.Relay as Relay
self.config = HaloRadio.conf
self.configdb = HaloRadio.configdb
self.hrSong = Song
self.hrRelay = Relay
def getCurrentSong(self):
cursong = int(self.configdb.GetConfigItem("current_song"))
if cursong == 0:
currelay = int(self.configdb.GetConfigItem("current_relay"))
r = self.hrRelay.Relay(currelay)
return r.GetDisplayName()
else:
s = self.hrSong.Song(cursong)
return s.GetDisplayName()
server = SimpleXMLRPCServer.SimpleXMLRPCServer(("*", 7014))
server.register_instance(HaloRPC())
server.serve_forever()
def setUp(self):
self.cgi = SimpleXMLRPCServer.CGIXMLRPCRequestHandler()
import SimpleXMLRPCServer, sys
import factorizar
usage = """
Usar serv_processes.py nroport
ej: serv_processes.py 9000
"""
if len(sys.argv) != 2:
print usage
sys.exit(-1)
port = int(sys.argv[1])
server = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', port))
server.register_function(factorizar.factoriz_sum)
server.serve_forever()
def launch_XMLRPC(hostname='', port=_xmlPort, nToTry=_nPortsToTry):
""" launches the xmlrpc server into a separate thread
Arguments:
hostname: (OPTIONAL) name of the host for the server
(defaults to be the name of the localhost)
port: (OPTIONAL) the first port to try for the server
nToTry: (OPTIONAL) the number of possible ports to try
(in case the first can't be opened)
"""
if not hostname:
import os
hostname = os.environ.get('PYMOL_RPCHOST', 'localhost')
global cgoDict, serv
cgoDict = {}
for i in range(nToTry):
try:
serv = SimpleXMLRPCServer.SimpleXMLRPCServer((hostname, port + i),
logRequests=0,
allow_none=True)
except:
serv = None
else:
break
if serv:
print('xml-rpc server running on host %s, port %d' %
(hostname, port + i))
# import PyMOL API
from pymol import api
serv.register_instance(cmd)
# legacy stuff with unique names
serv.register_function(rpcPing, 'ping')
serv.register_function(rpcResetCGO, 'resetCGO')
serv.register_function(rpcRenderCGO, 'renderCGO')
serv.register_function(rpcSphere, 'sphere')
serv.register_function(rpcSpheres, 'spheres')
serv.register_function(rpcCylinder, 'cylinder')
serv.register_function(rpcDeleteObject, 'deleteObject')
serv.register_function(rpcDeleteAll, 'deleteAll')
serv.register_function(rpcLoadPDB, 'loadPDB')
serv.register_function(rpcLoadMolBlock, 'loadMolBlock')
serv.register_function(rpcLoadSurface, 'loadSurface')
serv.register_function(rpcLoadSurfaceData, 'loadSurfaceData')
serv.register_function(rpcLoadFile, 'loadFile')
serv.register_function(rpcGetNames, 'getNames')
serv.register_function(api.count_atoms, 'countAtoms')
serv.register_function(rpcIdAtom, 'idAtom')
serv.register_function(rpcHelp, 'help')
serv.register_function(rpcGetAtomCoords, 'getAtomCoords')
# legacy stuff, should be removed because overwrites API names!
serv.register_function(rpcLabel, 'label') # pseudoatom
serv.register_function(rpcRotate, 'rotate')
serv.register_introspection_functions()
t = threading.Thread(target=serv.serve_forever)
t.setDaemon(1)
t.start()
else:
print('xml-rpc server could not be started')
def start_listen(self):
self.s = SimpleXMLRPCServer.SimpleXMLRPCServer(
self.serveradd, logRequests=False) #start a RPC Server
self.s.register_instance(self) # register RPC bject
self.s.serve_forever() # start listening
def __init__(self):
gr.top_block.__init__(self, "NBFM Receiver V2- F1ATB - MARCH 2021")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 1200000
self.Largeur_filtre = Largeur_filtre = 10000
self.xlate_filter_taps = xlate_filter_taps = firdes.low_pass(1, samp_rate, Largeur_filtre/2, 1500)
self.decim_LP = decim_LP = 16
self.Squelch = Squelch = -80
self.Gain_RF = Gain_RF = 30
self.Gain_IF = Gain_IF = 20
self.Gain_BB = Gain_BB = 20
self.FrRX = FrRX = 145000000
self.F_Fine = F_Fine = 0
##################################################
# Blocks
##################################################
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 9003), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
self.xmlrpc_server_0_thread = threading.Thread(target=self.xmlrpc_server_0.serve_forever)
self.xmlrpc_server_0_thread.daemon = True
self.xmlrpc_server_0_thread.start()
self.pluto_source_0 = iio.pluto_source('192.168.2.1', 145000000, int(samp_rate), 1000000, 32768, True, True, True, "manual", 50, '', True)
self.low_pass_filter_0 = filter.fir_filter_ccf(1, firdes.low_pass(
1, decim_LP*samp_rate/200, 5200, 1200, firdes.WIN_HAMMING, 6.76))
self.logpwrfft_x_0 = logpwrfft.logpwrfft_c(
sample_rate=samp_rate/100,
fft_size=2048,
ref_scale=0.00001,
frame_rate=samp_rate/100/2048,
avg_alpha=1.0,
average=False,
)
self.iio_attr_updater_0_0 = iio.attr_updater('hardwaregain', str(int(Gain_RF*1.75)), 1000)
self.iio_attr_updater_0 = iio.attr_updater('frequency', str(int(FrRX)), 1000)
self.iio_attr_sink_0_0 = iio.attr_sink("ip:192.168.2.1", "ad9361-phy", "voltage0", 0, False, False)
self.iio_attr_sink_0 = iio.attr_sink("ip:192.168.2.1", "ad9361-phy", "altvoltage0", 0, True, False)
self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(30, (xlate_filter_taps), F_Fine, samp_rate)
self.fractional_resampler_xx_0 = filter.fractional_resampler_cc(0, decim_LP/2)
self.blocks_udp_sink_1 = blocks.udp_sink(gr.sizeof_short*2048, '127.0.0.1', 9002, 4096, True)
self.blocks_udp_sink_0 = blocks.udp_sink(gr.sizeof_short*1, '127.0.0.1', 9001, 1000, True)
self.blocks_pdu_remove_0 = blocks.pdu_remove(pmt.intern("key"))
self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_gr_complex, int(1024*decim_LP), 204800, 0)
self.blocks_float_to_short_1 = blocks.float_to_short(2048, 100)
self.blocks_float_to_short_0 = blocks.float_to_short(1, 16000)
self.analog_simple_squelch_cc_0 = analog.simple_squelch_cc(Squelch, 0.001)
self.analog_nbfm_rx_0 = analog.nbfm_rx(
audio_rate=int(samp_rate/120),
quad_rate=int(samp_rate/30),
tau=75e-6,
max_dev=5e3,
)
##################################################
# Connections
##################################################
self.msg_connect((self.iio_attr_updater_0, 'out'), (self.iio_attr_sink_0, 'attr'))
self.msg_connect((self.iio_attr_updater_0_0, 'out'), (self.iio_attr_sink_0_0, 'attr'))
self.connect((self.analog_nbfm_rx_0, 0), (self.blocks_float_to_short_0, 0))
self.connect((self.analog_simple_squelch_cc_0, 0), (self.analog_nbfm_rx_0, 0))
self.connect((self.blocks_float_to_short_0, 0), (self.blocks_udp_sink_0, 0))
self.connect((self.blocks_float_to_short_1, 0), (self.blocks_udp_sink_1, 0))
self.connect((self.blocks_keep_m_in_n_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.fractional_resampler_xx_0, 0), (self.logpwrfft_x_0, 0))
self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.analog_simple_squelch_cc_0, 0))
self.connect((self.logpwrfft_x_0, 0), (self.blocks_float_to_short_1, 0))
self.connect((self.low_pass_filter_0, 0), (self.fractional_resampler_xx_0, 0))
self.connect((self.pluto_source_0, 0), (self.blocks_keep_m_in_n_0, 0))
self.connect((self.pluto_source_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0))
import SimpleXMLRPCServer
def soucet(a, b):
return a + b
def rozdil(a, b):
return a - b
server = SimpleXMLRPCServer.SimpleXMLRPCServer(("", 8080))
server.register_function(soucet)
server.register_function(rozdil)
server.serve_forever()
def Run(self):
server = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", self.app.port))
server.register_instance(PostAppServer(self.app))
while self.keepGoing:
server.handle_request( )
self.running = False
def main():
# Get configuration yaml
config_path = os.path.join(os.path.dirname(__file__), 'config.yaml')
with open(config_path, 'r') as ymlfile:
config = yaml.load(ymlfile)
# Setup logging based on verbosity flag in config.yaml
log = logging.getLogger('')
log.setLevel(logging.DEBUG)
log_format = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
ch = logging.StreamHandler(sys.stdout)
ch.setFormatter(log_format)
log.addHandler(ch)
if config['verbose']:
log_path = os.path.dirname(__file__) + config['logging']['log_path']
fh = handlers.RotatingFileHandler(
"%s/%s.log" % (log_path, config['logging']['log_name']),
backupCount=7)
fh.setFormatter(log_format)
log.addHandler(fh)
# Create Bank object which creates connection with bank server
# a dummy counterpart is also available for use
logging.info('Initializing Bank...')
if config['devices']['bank']['dummy']:
bank = DummyBank()
else:
bank = Bank(config['devices']['bank']['host'],
config['devices']['bank']['port'])
logging.info('Bank initialized.')
# Create secmod object which creates connection with secmod psoc
# a emulated counterpart is also available for use
if config['devices']['hsm']['dummy']:
logging.info('Initializing DummyHSM ')
hsm = DummyHSM(verbose=config['verbose'], provision=True)
logging.info('DummyHSM initialized.')
else:
logging.info('Initializing HSM...')
hsm = HSM(verbose=config['verbose'])
logging.info('HSM initialized.')
# Create card object which connects and reconnects to inserted cards
if config['devices']['card']['dummy']:
logging.info('Initializing DummyCard...')
card = DummyCard(verbose=config['verbose'], provision=True)
logging.info('DummyCard initialized.')
else:
logging.info('Initializing Card...')
card = Card(verbose=config['verbose'])
logging.info('Card initialized.')
# Create ATM object with bank, hsm, and card instances
logging.info('Initializing ATM...')
atm = ATM(bank, hsm, card)
logging.info('ATM initialized.')
logging.info('Initializing Provision Tool...')
provision_tool = ProvisionTool(bank, hsm, card)
logging.info('Provision Tool initialized.')
# Start xmlrpc server on host and port specified in config.yaml
logging.info('Initializing ATM xmlrpc interface...')
server = SimpleXMLRPCServer.SimpleXMLRPCServer(
(config['devices']['atm']['host'], config['devices']['atm']['port']))
# Register built-in rpc introspections
server.register_introspection_functions()
# Register api exposed by atm and hsm
server.register_function(atm.hello)
server.register_function(atm.withdraw)
server.register_function(atm.check_balance)
server.register_function(atm.change_pin)
server.register_function(provision_tool.provision_card)
server.register_function(provision_tool.provision_atm)
server.register_function(provision_tool.ready_for_hsm)
server.register_function(provision_tool.hsm_connected)
server.register_function(provision_tool.card_connected)
logging.info('ATM xmlrpc interface initialized.')
logging.info('ATM listening on %s:%s' %
(config['devices']['atm']['host'],
str(config['devices']['atm']['port'])))
# Start xmlrpc server
t = threading.Thread(target=server.serve_forever)
t.daemon = True
t.start()
# Blocks until a hsm is connected
hsm.initialize()
# Spins up thread to connect/disconnect cards
card.initialize()
t.join()
Interface.free_invalid_data_block((block_number))
#REQUEST TO WRITE DATA ON THE THE SERVER
def update_data_block(self, p_block_number, p_block_data):
block_number = pickle.loads(p_block_number)
block_data = pickle.loads(p_block_data)
Interface.update_data_block(block_number, block_data)
#REQUEST TO UPDATE THE UPDATED INODE IN THE INODE TABLE FROM SERVER
def update_inode_table(self, p_inode, p_inode_number):
inode = pickle.loads(p_inode)
inode_number = pickle.loads(p_inode_number)
Interface.update_inode_table(inode, inode_number)
#REQUEST FOR THE STATUS OF FILE SYSTEM FROM SERVER
def status(self):
sta = Interface.status()
psta = pickle.dumps(sta)
return psta
obj = MyObject()
port = sys.argv[1]
server = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", int(port)), allow_none=True)
server.register_instance(obj)
print("Listening on port " + port)
server.serve_forever()
def __init__(self):
gr.top_block.__init__(self, "TJ Cubesat No Gui with IQ streaming")
##################################################
# Variables
##################################################
self.interp = interp = 4
self.audio_rate = audio_rate = 48000
self.tx_gain = tx_gain = 10
self.rx_downsamp_bw = rx_downsamp_bw = 10000
self.rf_tx_rate = rf_tx_rate = audio_rate*interp
self.rf_rx_rate = rf_rx_rate = 192000
self.preamble_len = preamble_len = 300
self.gain = gain = 40
self.freq = freq = 144.39e6
self.cubesat_zmq_port_4 = cubesat_zmq_port_4 = "5504"
self.cubesat_zmq_port_3 = cubesat_zmq_port_3 = "5503"
self.cubesat_zmq_port_2 = cubesat_zmq_port_2 = "5502"
self.cubesat_zmq_port_1 = cubesat_zmq_port_1 = "5501"
self.cubesat_port_2 = cubesat_port_2 = "5558"
self.cubesat_port_1 = cubesat_port_1 = "5556"
self.cubesat_ext_ip_addr = cubesat_ext_ip_addr = "192.168.1.10"
self.baud_rate = baud_rate = 1200
self.audio_line_driver = audio_line_driver = .8
self.Decay = Decay = 0.8
self.Attack = Attack = 0.8
##################################################
# Blocks
##################################################
self.zeromq_push_sink_0_0_0_0 = zeromq.push_sink(gr.sizeof_float, 1, "tcp://"+cubesat_ext_ip_addr+":"+cubesat_zmq_port_4, 100, False, -1)
self.zeromq_push_sink_0_0_0 = zeromq.push_sink(gr.sizeof_float, 1, "tcp://"+cubesat_ext_ip_addr+":"+cubesat_zmq_port_3, 100, False, -1)
self.zeromq_push_sink_0_0 = zeromq.push_sink(gr.sizeof_gr_complex, 1, "tcp://"+cubesat_ext_ip_addr+":"+cubesat_zmq_port_2, 100, False, -1)
self.zeromq_push_sink_0 = zeromq.push_sink(gr.sizeof_gr_complex, 1, "tcp://"+cubesat_ext_ip_addr+":"+cubesat_zmq_port_1, 100, False, -1)
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(('', 1234), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
self.xmlrpc_server_0_thread = threading.Thread(target=self.xmlrpc_server_0.serve_forever)
self.xmlrpc_server_0_thread.daemon = True
self.xmlrpc_server_0_thread.start()
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(rf_rx_rate)
self.uhd_usrp_source_0.set_center_freq(freq, 0)
self.uhd_usrp_source_0.set_gain(gain, 0)
self.uhd_usrp_source_0.set_antenna('RX2', 0)
self.uhd_usrp_source_0.set_bandwidth(rf_rx_rate, 0)
self.uhd_usrp_sink_0_1 = uhd.usrp_sink(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0_1.set_samp_rate(rf_tx_rate)
self.uhd_usrp_sink_0_1.set_center_freq(freq, 0)
self.uhd_usrp_sink_0_1.set_gain(tx_gain, 0)
self.uhd_usrp_sink_0_1.set_antenna('TX/RX', 0)
self.uhd_usrp_sink_0_1.set_bandwidth(rf_tx_rate, 0)
self.rational_resampler_xxx_0_0_0 = filter.rational_resampler_ccc(
interpolation=4,
decimation=1,
taps=None,
fractional_bw=None,
)
self.low_pass_filter_0 = filter.fir_filter_ccf(4, firdes.low_pass(
1, rf_rx_rate, rx_downsamp_bw/2, 1000, firdes.WIN_HAMMING, 6.76))
self.detectMarkSpace_1_0 = detectMarkSpace(
Frequency=2200,
attack=Attack,
decay=Decay,
samp_rate=audio_rate,
)
self.detectMarkSpace_0_0 = detectMarkSpace(
Frequency=1200,
attack=Attack,
decay=Decay,
samp_rate=audio_rate,
)
self.bruninga_str_to_aprs_0_1 = bruninga.str_to_aprs('KN4DTQ', 'KN4DTQ', [])
self.bruninga_ax25_fsk_mod_0_0 = bruninga.ax25_fsk_mod(audio_rate, preamble_len, 5, 2200, 1200, baud_rate)
self.blocks_udp_sink_0_0 = blocks.udp_sink(gr.sizeof_char*1, '127.0.0.1', int(cubesat_port_1), 1472, True)
self.blocks_sub_xx_0_0_0 = blocks.sub_ff(1)
self.blocks_socket_pdu_0_0_0_0 = blocks.socket_pdu("UDP_SERVER", '127.0.0.1', cubesat_port_2, 10000, False)
self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vff((audio_line_driver, ))
self.analog_nbfm_tx_0_0 = analog.nbfm_tx(
audio_rate=audio_rate,
quad_rate=audio_rate,
tau=75e-6,
max_dev=5e3,
fh=-1.0,
)
self.analog_nbfm_rx_0 = analog.nbfm_rx(
audio_rate=audio_rate,
quad_rate=audio_rate,
tau=75e-6,
max_dev=5e3,
)
self.afsk_ax25decode_1 = afsk.ax25decode(audio_rate, 1)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_socket_pdu_0_0_0_0, 'pdus'), (self.bruninga_str_to_aprs_0_1, 'in'))
self.msg_connect((self.bruninga_str_to_aprs_0_1, 'out'), (self.bruninga_ax25_fsk_mod_0_0, 'in'))
self.connect((self.afsk_ax25decode_1, 0), (self.blocks_udp_sink_0_0, 0))
self.connect((self.analog_nbfm_rx_0, 0), (self.detectMarkSpace_0_0, 0))
self.connect((self.analog_nbfm_rx_0, 0), (self.detectMarkSpace_1_0, 0))
self.connect((self.analog_nbfm_rx_0, 0), (self.zeromq_push_sink_0_0_0, 0))
self.connect((self.analog_nbfm_tx_0_0, 0), (self.rational_resampler_xxx_0_0_0, 0))
self.connect((self.blocks_multiply_const_vxx_0_0, 0), (self.analog_nbfm_tx_0_0, 0))
self.connect((self.blocks_sub_xx_0_0_0, 0), (self.afsk_ax25decode_1, 0))
self.connect((self.bruninga_ax25_fsk_mod_0_0, 0), (self.blocks_multiply_const_vxx_0_0, 0))
self.connect((self.bruninga_ax25_fsk_mod_0_0, 0), (self.zeromq_push_sink_0_0_0_0, 0))
self.connect((self.detectMarkSpace_0_0, 0), (self.blocks_sub_xx_0_0_0, 0))
self.connect((self.detectMarkSpace_1_0, 0), (self.blocks_sub_xx_0_0_0, 1))
self.connect((self.low_pass_filter_0, 0), (self.analog_nbfm_rx_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.zeromq_push_sink_0, 0))
self.connect((self.rational_resampler_xxx_0_0_0, 0), (self.uhd_usrp_sink_0_1, 0))
self.connect((self.rational_resampler_xxx_0_0_0, 0), (self.zeromq_push_sink_0_0, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.low_pass_filter_0, 0))
def __init__(self):
gr.top_block.__init__(self, "rfnoc_rx_e3")
##################################################
# Variables
##################################################
self.vec_length = vec_length = 1
self.device3 = variable_uhd_device3_0 = ettus.device3(
uhd.device_addr_t(",".join(('type=e3x0', ""))))
self.server_port = server_port = 30000
self.server_address = server_address = "192.168.10.184"
self.samp_rate = samp_rate = 1e6
self.rx_gain_A2 = rx_gain_A2 = 60
self.rf_freq = rf_freq = 871e6
self.decim_rate = decim_rate = 500e3
##################################################
# Blocks
##################################################
self.zeromq_push_sink_1 = zeromq.push_sink(gr.sizeof_gr_complex,
vec_length, 'tcp://*:9998',
100, False, -1)
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(
(str(server_address), int(server_port)), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
self.xmlrpc_server_0_thread = threading.Thread(
target=self.xmlrpc_server_0.serve_forever)
self.xmlrpc_server_0_thread.daemon = True
self.xmlrpc_server_0_thread.start()
self.uhd_rfnoc_streamer_radio_0 = ettus.rfnoc_radio(
self.device3,
uhd.stream_args( # Tx Stream Args
cpu_format="fc32",
otw_format="sc16",
args="", # empty
),
uhd.stream_args( # Rx Stream Args
cpu_format="fc32",
otw_format="sc16",
args='',
),
0,
-1)
self.uhd_rfnoc_streamer_radio_0.set_rate(samp_rate)
self.uhd_rfnoc_streamer_radio_0.set_rx_freq(rf_freq, 0)
self.uhd_rfnoc_streamer_radio_0.set_rx_gain(rx_gain_A2, 0)
self.uhd_rfnoc_streamer_radio_0.set_rx_dc_offset(True, 0)
self.uhd_rfnoc_streamer_radio_0.set_rx_bandwidth(samp_rate, 0)
if "RX2":
self.uhd_rfnoc_streamer_radio_0.set_rx_antenna("RX2", 0)
self.uhd_rfnoc_streamer_radio_0.set_clock_source("internal")
self.uhd_rfnoc_streamer_ddc_0 = ettus.rfnoc_generic(
self.device3,
uhd.stream_args( # TX Stream Args
cpu_format="fc32", # TODO: This must be made an option
otw_format="sc16",
channels=range(1),
args=
"input_rate={},output_rate={},fullscale={},freq={},gr_vlen={},{}"
.format(
samp_rate, samp_rate, 1.0, 0, vec_length,
"" if vec_length == 1 else "spp={}".format(vec_length)),
),
uhd.stream_args( # RX Stream Args
cpu_format="fc32", # TODO: This must be made an option
otw_format="sc16",
channels=range(1),
args="gr_vlen={},{}".format(
vec_length,
"" if vec_length == 1 else "spp={}".format(vec_length)),
),
"DDC",
-1,
-1,
)
for chan in xrange(1):
self.uhd_rfnoc_streamer_ddc_0.set_arg("input_rate",
float(samp_rate), chan)
self.uhd_rfnoc_streamer_ddc_0.set_arg("output_rate",
float(samp_rate), chan)
self.uhd_rfnoc_streamer_ddc_0.set_arg("fullscale", 1.0, chan)
self.uhd_rfnoc_streamer_ddc_0.set_arg("freq", 0, chan)
##################################################
# Connections
##################################################
self.connect((self.uhd_rfnoc_streamer_ddc_0, 0),
(self.zeromq_push_sink_1, 0))
self.device3.connect(self.uhd_rfnoc_streamer_radio_0.get_block_id(), 0,
self.uhd_rfnoc_streamer_ddc_0.get_block_id(), 0)
def rpc_server():
rpcserver = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 8004),
logRequests=False)
rpcserver.register_function(announce, 'announce')
print 'Starting xml rpc server...'
rpcserver.serve_forever()
def __init__(self, channel=6):
gr.top_block.__init__(self, "Wifi Rx")
##################################################
# Parameters
##################################################
self.channel = channel
##################################################
# Variables
##################################################
self.window_size = window_size = 48
self.sync_length = sync_length = 320
self.samp_rate = samp_rate = 20e6
self.lo_offset = lo_offset = 0
self.gain = gain = 30
self.freq = freq = 2407000000.0 + 5000000.0 * channel
self.chan_est = chan_est = 0
##################################################
# Blocks
##################################################
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(
('localhost', 8080), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
self.xmlrpc_server_0_thread = threading.Thread(
target=self.xmlrpc_server_0.serve_forever)
self.xmlrpc_server_0_thread.daemon = True
self.xmlrpc_server_0_thread.start()
self.rftap_rftap_encap_0 = rftap.rftap_encap(0, -1, '')
self.osmosdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " +
'')
self.osmosdr_source_0.set_sample_rate(samp_rate)
self.osmosdr_source_0.set_center_freq(freq, 0)
self.osmosdr_source_0.set_freq_corr(0, 0)
self.osmosdr_source_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_0.set_gain_mode(False, 0)
self.osmosdr_source_0.set_gain(gain, 0)
self.osmosdr_source_0.set_if_gain(20, 0)
self.osmosdr_source_0.set_bb_gain(20, 0)
self.osmosdr_source_0.set_antenna('', 0)
self.osmosdr_source_0.set_bandwidth(0, 0)
self.ieee802_11_sync_short_0 = ieee802_11.sync_short(
0.56, 2, False, False)
self.ieee802_11_sync_long_0 = ieee802_11.sync_long(
sync_length, False, False)
self.ieee802_11_parse_mac_0 = ieee802_11.parse_mac(True, True)
self.ieee802_11_moving_average_xx_1 = ieee802_11.moving_average_ff(
window_size + 16)
self.ieee802_11_moving_average_xx_0 = ieee802_11.moving_average_cc(
window_size)
self.ieee802_11_frame_equalizer_0 = ieee802_11.frame_equalizer(
chan_est, freq, samp_rate, False, False)
self.ieee802_11_decode_mac_0 = ieee802_11.decode_mac(True, False)
self.fft_vxx_0 = fft.fft_vcc(64, True, (window.rectangular(64)), True,
1)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, 64)
self.blocks_socket_pdu_0_0_0 = blocks.socket_pdu(
"UDP_CLIENT", '127.0.0.1', '52002', 10000, False)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_divide_xx_0 = blocks.divide_ff(1)
self.blocks_delay_0_0 = blocks.delay(gr.sizeof_gr_complex * 1, 16)
self.blocks_delay_0 = blocks.delay(gr.sizeof_gr_complex * 1,
sync_length)
self.blocks_conjugate_cc_0 = blocks.conjugate_cc()
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(1)
##################################################
# Connections
##################################################
self.msg_connect((self.ieee802_11_decode_mac_0, 'out'),
(self.ieee802_11_parse_mac_0, 'in'))
self.msg_connect((self.ieee802_11_decode_mac_0, 'out'),
(self.rftap_rftap_encap_0, 'in'))
self.msg_connect((self.rftap_rftap_encap_0, 'out'),
(self.blocks_socket_pdu_0_0_0, 'pdus'))
self.connect((self.blocks_complex_to_mag_0, 0),
(self.blocks_divide_xx_0, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0),
(self.ieee802_11_moving_average_xx_1, 0))
self.connect((self.blocks_conjugate_cc_0, 0),
(self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_delay_0, 0),
(self.ieee802_11_sync_long_0, 1))
self.connect((self.blocks_delay_0_0, 0),
(self.blocks_conjugate_cc_0, 0))
self.connect((self.blocks_delay_0_0, 0),
(self.ieee802_11_sync_short_0, 0))
self.connect((self.blocks_divide_xx_0, 0),
(self.ieee802_11_sync_short_0, 2))
self.connect((self.blocks_multiply_xx_0, 0),
(self.ieee802_11_moving_average_xx_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.fft_vxx_0, 0),
(self.ieee802_11_frame_equalizer_0, 0))
self.connect((self.ieee802_11_frame_equalizer_0, 0),
(self.ieee802_11_decode_mac_0, 0))
self.connect((self.ieee802_11_moving_average_xx_0, 0),
(self.blocks_complex_to_mag_0, 0))
self.connect((self.ieee802_11_moving_average_xx_0, 0),
(self.ieee802_11_sync_short_0, 1))
self.connect((self.ieee802_11_moving_average_xx_1, 0),
(self.blocks_divide_xx_0, 1))
self.connect((self.ieee802_11_sync_long_0, 0),
(self.blocks_stream_to_vector_0, 0))
self.connect((self.ieee802_11_sync_short_0, 0),
(self.blocks_delay_0, 0))
self.connect((self.ieee802_11_sync_short_0, 0),
(self.ieee802_11_sync_long_0, 0))
self.connect((self.osmosdr_source_0, 0),
(self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.osmosdr_source_0, 0), (self.blocks_delay_0_0, 0))
self.connect((self.osmosdr_source_0, 0),
(self.blocks_multiply_xx_0, 0))
